The sum of the squares of the first ten natural numbers is,
1^(2) + 2^(2) + … + 10^(2) = 385

The square of the sum of the first ten natural numbers is,
(1 + 2 + … + 10)^(2) = 55^(2) = 3025

Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 − 385 = 2640.

Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.

Brute Force Approach

This was an unusual problem for Project Euler as the brute force approach was both easy to code and ran well within the time constraints (6 milliseconds on my laptop). My first solution was as follows:

	public int euler6(int n) {
		int sumOfSquares = 0;
		int squareOfSum = 0;
		for (int i=1; i<=n; i++) {
			sumOfSquares +=  (i*i);
			squareOfSum += i;
		}
		squareOfSum *= squareOfSum;

		int ans = squareOfSum-sumOfSquares;
		return ans;
	}

This brute force approach (with a Big-O analysis of O(n)) took just 5 milliseconds on my laptop. Given that that time limit is 1 minute, there wasn’t a lot of motivation for finding a better solution.

None the less, I started analyzing the numbers, looking for patterns etc but I have to be honest, I couldn’t find much. So, I started Googling!

Key 1

First I came across the work of Gauss. I have to admit I have never heard of his work before, but clearly he was much smarted than me.

At the age of only 10, he figured out that the sum of all numbers up to n can be calculated at n(n+1)/2
e.g. 1+2+3+4+5+6+7+8+9+10 = 10(5)/2=25
There are a couple of good pages about this here and here.

Key 2

Next, I found this very cool formula for the sum of squares:
For a number n, 1^2 + 2^2 + 3^2 +…. n^2 =
n(n + 1)(2n + 1)/6

e.g. the sum of squares
=1+4+9+16+25+36+49+64+91+100=385
Or
=10(10+1)(20+1)/6
=10(11)(21)/6
=110(21)/6
=2310/6
=385

Magic!
I found the best explanation of this here.

Final Solution

So, given those 2 formulae, we can rewrite out Project Euler #6 solution as:

	public int euler6(int n) {
		int sumOfSquares = n* (n + 1) * (2*n + 1) /6;
		int sum = n*(n+1)/2;
		int squareOfSum = sum*sum;
		int ans = squareOfSum-sumOfSquares;
		return ans;
	}

Which runs in constant time or O(1).
I would never have figured out those formulae myself, but they are pretty cool to know!

2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.

What is the smallest number that is evenly divisible by all of the numbers from 1 to 20?

As usual, I started with the brute force approach:

	int max=20;
	long candidate = 1;
	boolean success = false;
	do {
		int i;
		for (i=1; i<=max; i++) {
			if ((candidate % i) !=0) {
				//out.println(candidate + " not divisible by " + i);
				candidate=candidate+1;
				break;
			}
		}
		if (i>max) success = true;
	} while (!success);
	out.println("Success: " + candidate);

This is clearly a poor solution (and at ~25 seconds run time on my laptop, a very slow one).
A few improvement points:
1) The result has to be divisible by all numbers up to and including 20. So no point checking any number below 20. So we could change the starting candidate value to 20. But using the info given, we know that 2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder. So the solution can’t be smaller than 2520. Let’s start there.
2) Any number has to be divisible by 20, so we can increment candidate by 20 each time.
3) If a candidate is divisible by 20, it is definitely divisible by 10, so don’t even bother checking 10. If a number is divisible by 18, it is definitely devisible by 9, so don’t bother checking 9. Continue this process and we find that we only need to check if a candidate number is divisible by 11 through 19 (we are starting with a multiple of 20 and incrementing by 20 each time, so 20 as a factor is a given).
This leaves us with this slightly better solution:

	int min = 11;
	int max=19;
	long candidate = 2520;
	boolean success = false;
	do {
		int i;
		for (i=min; i<=max; i++) {
			if ((candidate % i) !=0) {
				//out.println(candidate + " not divisible by " + i);
				candidate=candidate+20;
				break;
			}
		}
		if (i>max) success = true;
	} while (!success);
	out.println("Success: " + candidate);

This give the same solution, but with about 400 milliseconds running time. Better, and well within the 1 minute Project Euler limit.
I submitted my solution and confirmed it was correct.
Great. But I knew my solution was still a brute force approach at heart.

As I was working through the algorithm, I began thinking about using a better starting point than 2520. For example, the smallest solution must be a number that is divisible by both 19 and 20. What is that? If I had a method that told me the lowest common multiple of 19 and 20?
As I started reading through other solutions, I began thinking more about that. If I had a function getLowestCommonMultipler(a, b)
I could apply that to the first 2 numbers (1 and 2).
Then use the result for a subsequent call, e.g. getLowestCommonMultipler(result, 3)
Then use the result for a subsequent call, e.g. getLowestCommonMultipler(result, 4)
and so on.
You would end with a solution like this

	int max=20;
	long lowestCommonMultipler = 1;
	for (int i=2; i<=max; i++) {
		lowestCommonMultipler = getLowestCommonMultipler(lowestCommonMultipler, i);
	}
	out.println("Success: " + lowestCommonMultipler);

I admit that I had to get ‘inspiration’ for the implementation of the getLowestCommonMultipler() method elsewhere (see here, for example), so I won’t post the implementation as it is not my own work. But identifying the need for such a method is the big breakthrough I think. The above solution ran in 6ms for me. Cool in a very geeky, Project Euler kind of way.

A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 × 99.

Find the largest palindrome made from the product of two 3-digit numbers.

I found this problem significantly easier than problem 3, thankfully.

My first step was to write a helper method:

	boolean isPalindrome(int num)

My first attempt was, as usual, the brute force approach. Namely, go through every number from 100 to 999 and for each, multiply it by every number between 100 and 999. Check if the result of each of the roughly one million calculations is a palindrome – and store it if it is the biggest one yet.

My next approach was better and involved starting from the top (999 to 100) instead of the other way round. This means we can check if the largest palindrome we could possible find is smaller than what we have already found, thereby avoiding a large number of useless calculations.

This gave me a solution that runs in approx 500ms on my local PC.

Here is my final solution:

int largestPalindrome = 0;
for (i in 999..100) {
	if ( (i*i) < largestPalindrome) {
		//the largest possible number we can now find (i*i)
		//is smaller than the biggest palindrome already found
		break;
	}
	for (j in i..100) {
		int candidate = i*j;
		if ( candidate < largestPalindrome) {
			//largest number we can now find in this inner loop
			//is smaller than the biggest palindrome already found
			break;
		}
		if (isPalindrome(candidate)) {
			if (candidate>largestPalindrome) {
				largestPalindrome = candidate;
				break;//no point checking smaller numbers of j
			}
		}
	}
}
println("largestPalindrome);

And finally, my isPalindrome method:

public static boolean isPalindrome(Integer num) {
	boolean isPalindrome=true;
	char[] numChars = num.toString().toCharArray();
	int endPoint = numChars.length() - 1;
	int midPoint = numChars.length() / 2;
	for (i in 0..midPoint) {
		char a = numChars[i];
		char b = numChars[endPoint-i];
		if (a != b) {
			isPalindrome=false;
			break;
		}
	}
	return isPalindrome;
}

The prime factors of 13195 are 5, 7, 13 and 29.
What is the largest prime factor of the number 600851475143 ?

I noticed some performance issues with Groovy when I was working on this solution. I will blog about my findings later (Update: see here), suffice to say I am switching to straight Java for this solution.

After experimenting with a brute force approach, I finally came up with this solution. It is not the most elegant, but it works (in <100ms).

long x = 600851475143L;
long max = x / 2;
long factor = x;
long lastFactor = x;
for (long i=2; i<max; i++) {
	long remainder = x % i;
	lastFactor = factor;
	factor = x/i;
	if ( (remainder == 0) && (eule3.isPrime(factor)) ) {
		printAndExit(factor);
	}			

	if (factor >= lastFactor-1) {
		for (long j=factor; j>2; j--) {
			i++;
			remainder = x % j;
			if (remainder == 0) {
				if (eule3.isPrime(j)) {
					printAndExit(j);
				}
			}
		}
	}
}

There are 2 main parts to the solution. The first loop starts at x/2 (since no factor of x can be greater than x/2). Basically we are checking if x/2 (rounded) is a factor of x. Then 3, then 4 etc. And when we find a number that is a factor, we check if it is prime (if so, we stop obviously). So, for example, we check if 50, 33, 25 are factors of x.

This approach works great, until a certain point, which is when we switch into the second loop. Basically, it becomes more inefficient to start checking if sequential numbers are factors of x.

Again, not the most efficient algorithm, or very well explained! But I have spent enough time on this one.

On to Problem 4...

Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:

1, 2, 3, 5, 8, 13, 21, 34, 55, 89, …

Find the sum of all the even-valued terms in the sequence which do not exceed four million.

I found it fairly easy to code a basic solution to this problem:

	    def fibSeries = [0,1]
	    int sumOfEvenNums = 0
	    int i = 0
	    while (fibSeries[i]<=4000000) {
	       i = fibSeries.size
	       fibSeries[i] = fibSeries[i-1]+fibSeries[i-2]
	       if (fibSeries[i]%2==0) {
	    	   sumOfEvenNums+=fibSeries[i]
	       }
	    }
	    println("Total = " + sumOfEvenNums)

This ran relatively quickly (~100ms), so I submitted my answer on projecteuler.net and it was confirmed as correct.

With heinsight, I realise that it is unnecessary for me to store the entire sequence of numbers (in fibSeries). I just need to store 3 numbers: the latest and the previous 2.

After checking the solution notes, there is of course a more ‘perfect’ solution. Reaching it involves making 2 breakthroughs, which I admit I didn’t make on my own!

Breakthrough 1
The first breakthrough is to see the pattern (how could I have missed it!) that only every 3rd number is even, meaning we can safely ignore the rest. The provided solution says that this is easy to prove (I have no idea how to – perhaps a step for another day). But assuming this to be true, the code can be rewritten to

	    int a,b,c
	    b = 1 //1st seed value
	    c = 1 //2nd seed value
	    int sumOfEvenNums = 0
	    while (c<=4000000) {
	       a=b+c
	       b=c+a
	       c=a+b
	       sumOfEvenNums+=a
	    }
	    println("Total = " + sumOfEvenNums)

Breakthrough 2
The second, and waaay more difficult breakthrough is to spot (and prove!) that there is a pattern in the even numbers. If you look at them,
2, 8, 34, 144, 610, …
They obey following recursive relation:
E(n)=4*E(n-1)+E(n-2).
e.g. 144=4(34) + 8
and 34 = 4(8) + 2
It can be proved that for the Fibonacci numbers, the formula F(n)=4*F(n-3)+F(n-6) holds true (I even managed to get the proof of this myself, after a little prodding).

So, this leaves the following ‘ultimate’ solution:

	    int a = 0
	    int b = 8 //1st seed value
	    int c = 2 //2nd seed value
	    int sumOfEvenNums = b+c
	    while (true) {
	       a=(4*b)+c
	       if (a>4000000) break
	       sumOfEvenNums+=a
	       c=b
	       b=a
	    }
	    println("Total = " + sumOfEvenNums)

I am sure this could even be rewritten in a more elegant form. Especially if Groovy supported a do..while loop.

Anyway, on to Problem#3…

    find /dir/to/search -name "filename.ext" -print 2>/dev/null

And wildcards are allowed. e.g.

    find /dir/to/search -name "filename.*" -print 2>/dev/null

The command searches /dir/to/search AND all sub directories.

The ’2>/dev/null’ avoids those annoying “find: cannot read dir …: Permission denied” errors.

Also, if you want to search for files containing specific text, try

    find /dir/to/search -exec grep -il "txtToSearchFor" {} \;

The “-il” means ignore case and print only the names of files with matching lines (as opposed to the line contents).

See also:
http://en.wikipedia.org/wiki/Find
http://www.unix.com/unix-dummies-questions-answers/3152-find-files-containing-text.html

I managed to solve Problem#1 today.

Note that I would describe the solutions below as being in Groovy/Java because I still fall back on my old Java habits rather than using all the Groovy language constructs available to me. Anyway…

The problem is:

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23. Find the sum of all the multiples of 3 or 5 below 1000.

Unsurprisingly, I took the brute force approach first:

int n = 999, total=0;
for (int i in 1..n) {
    if ( (i%3==0) || (i%5==0) ) {
        total=total+i;
    }
}
println("Total=" + total)

A good first start, but far from perfect as it loops through every number between 1 and n. I could improve it slightly by tweaking the start and end points (e.g. starting at 3), but it would still roughly involve n iterations.
My second attempt was this:

int n = 999, total=0;
Set nums = new HashSet();
for (int i=3; i<n+1; i=i+3) {
    if (nums.add(i)) total=total+i;
}
for (int i=5; i<n+1; i=i+5) {
     if (nums.add(i)) total=total+i;
}
println("Total="+total)

Note the use of the HashSet to avoid counting duplicates (i.e. numbers divisible by 3 and 5, like 15, 30 etc). Obviously the code could be tidied up but this reduced the number of loop iterations from 999 to 532 (and the run time from ~110ms to ~90ms).

However, the code/algorithm is still imperfect as although it doesn’t count numbers divisible by 3 and 5 twice, it still iterates over them twice. I couldn’t figure out a way to avoid this, so having met the requirements (I verified the correct answer on the Euler site and, at ~90ms, it runs well under one second), I submitted my answer and started reading the supplied solution.

The ‘perfect’ solution involves 3 breakthroughs.
The first is that the ideal solution involves using formulae, not iteration.
The second is that in the example of the total all numbers up to 1000 divisible by 3
i.e.
3+6+9+ … +999
= 3*(1+2+3+…+1000/3)
where 1000 divided by 3 is rounded down.

The 3rd and final breakthrough required is that:
1+2+3+…+y
= (y/2)*(y+1)

I have to admit that I am not sure I would have ever made these break throughs myself!

But using these facts, the ideal solution is along the following lines:

	static int max = 999;

	static void main(def args) {
	  int total = sumDivisibleBy(3)+sumDivisibleBy(5)-sumDivisibleBy(15)
	  println("\nTotal="+total)
	}

	static int sumDivisibleBy(n) {
	  int p=max / n
	  return n*(p*(p+1)) / 2
	}

This solution reduced the run time from ~90ms to ~20ms.

Next up, Problem#2…

I have a few ideas for upcoming articles, and I am also thinking about taking the Spring Certification exam. If so, I will be sure to post about it here…