I attended the qualification round of the hackercup, the requirement was to solve at least one of three problems to proceed to the next phase.
I chose to try to solve the first problem, that took me a whole night of thinking, more than I would like to admit I have to say :P, though I've passed this first part of the cup.

The problem

A double-square number is an integer X which can be expressed as the sum of two perfect squares.
For example, 10 is a double-square because 10 = 32 + 12. Your task in this problem is, given X, determine the number of ways in which it can be written as the sum of two squares. For example, 10 can only be written as 32 + 12 (we don't count 12 + 32 as being different). On the other hand, 25 can be written as 52 + 02 or as 42 + 32.

Input

You should first read an integer N, the number of test cases. The next N lines will contain N values of X.
Constraints
0 < X < 2147483647
1 < N < 100
Example input
5
10
25
3
0
1

Output

For each value of X, you should output the number of ways to write X as the sum of two squares.
Example output
1
2
0
1
1

Here is my solution:

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Scanner;
 
public class Puzzle {
 
	public static void main(String[] args) throws FileNotFoundException {
		Scanner scanner = new Scanner(new File(args[0]));
		//jump over the first, which tells how many ints there will be
		scanner.nextInt();
		while(scanner.hasNextInt()){
			int numberToTest = scanner.nextInt();
 
			if(numberToTest==0){
				System.out.println(1);
				continue;
			}
 
			Collection<String> foundSquares = new ArrayList<String>();
			int integerPart = (int)Math.sqrt(numberToTest); 
			while(integerPart>0){
				if(pow2(integerPart) == numberToTest){
					//integerPart is a perfect square
					foundSquares.add(String.valueOf(integerPart));
					integerPart--;
					continue;
				}
 
				int remainder = (int) (numberToTest - pow2(integerPart));
				if(pow2(integerPart)+pow2(remainder)==numberToTest){
					String toBeAdded = integerPart+":"+remainder;
					if(! foundSquares.contains(toBeAdded)){
						foundSquares.add(toBeAdded);
					}
				}
				if(isPerfectSquare(remainder) && pow2(integerPart)+remainder==numberToTest){
					String toBeAdded = String.valueOf(integerPart+":"+root2(remainder));
					String toBeAddedReversed = String.valueOf(root2(remainder)+":"+integerPart);
					if(!foundSquares.contains(toBeAdded) && !foundSquares.contains(toBeAddedReversed)){
						foundSquares.add(toBeAdded);
					}
				}
				integerPart--;
			}
 
			System.out.println(foundSquares.size());
		}
	}
 
	private static int pow2(int number){
		return (int)Math.pow(number, 2);
	}
 
	private static int root2(int number){
		return (int)Math.pow(number, 0.5);
	}
 
	public final static boolean isPerfectSquare(long number){
		if (number<0){
			return false;
		}
		long test = (long)(Math.sqrt(number));
		return test*test == number;
	}
}

Some thoughts

After watching my code for some time I start to feel that something is wrong might be improved, in most cases this has proved right, this time is no exception.
I'm not talking about this kind of improvement, I'm talking about not having useless code that is also readable. I'll start by pointing out what is readable for me and what is not.

Chunks of readable code

I like the usage of java.util.Scanner to read files, this time this proved particularly useful due to the fact that integers were separated by spaces, so just saying "hey scanner give me the next integer you will find", seems good to me. Note that the default limiter is the whitespace, so, again, it's okay.

Due to the large use of powers and roots I chose to put them in two methods, also because of the fact that they were easy to confuse with each other since they only differ by the second parameter.

Chunks of not-so-readable-code

The whole part inside the second while (starting at line 24) takes a lot more than a few seconds to be understood. I believe that the part of the class in which "the stuff is happening" should be easily readable, so one can read what is going on in a few seconds, I believe it is ok then to have more complex private methods that go deeper in detail, handling what is delegated from the part I'm talking about.
In particular I find that the reason behind adding the found squares to a Collection is quite obscure, it has to be clarified, the way it is now it's simply wrong unreadable.

Get the source code here.