Project Euler: Problem 5

Torleif — Mon, 21 Sep 2009 20:20:01 +0000

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?

Solution

This one I solved fairly quickly. That is, I wrote a solution to it fairly quickly. However, that solution was not a quick one. It was a pure brute-force without much cleverness behind, and it took between 30 and 100 seconds, if I remember correctly, to run. Not good. It basically just took the numbers, one by one, and tried to divide them by all the dividers. If the number was not evenly divisible by a divisor, it skipped to the next number and so on until it found the one that was divisible by all of them.

However, with some reading around I found a better and faster solution.

It apparently uses something called Folding, but I haven’t quite managed to grasp what that means, so I will just give you my own explanation (which I think and hope is correct ).

What we are looking for here is something called the Lowest Common Multiple (LCM). The LCM of all the divisors, 1 to 20, is the answer to this problem. To calculate the LCM of all those numbers we first need two methods.

The first is one that finds the LCM of two numbers. The formula for that, however, is based on another method which finds the Greatest Common Divisor (GCD) of two numbers. In other words we need to make that method first.

I implemented the GCD method using the Euclidean algorithm, and it goes like this:

public static ulong GetGreatestCommonDivisor(ulong a, ulong b)
{
while (b != 0)
{
ulong t = b;
b = a%b;
a = t;
}
return a;
}

Now we can find the LCM.

public static ulong GetLowestCommonMultiple(ulong a, ulong b)
{
return a / GetGreatestCommonDivisor(a, b) * b;
}

With those two in place, we can then create a simple “expanded” version of that which can take an arbitrary number of divisors using a smart method called Aggregate.

public static ulong GetLowestCommonMultiple(ulong[] divisors)
{
return divisors.Aggregate(1UL, (lcm, n) => GetLowestCommonMultiple(lcm, n));
}

It goes like this: It starts with 1 as the LCM and finds the LCM of 1 and the first divisor, n, and stores it in lcm. It then goes to the next divisor, and finds the LCM of that and the stored lcm, which is again stored in lcm. This is repeated until there are no more divisors, and we have the answer. As it turns out this method can also be simplified a bit because we can just give the LCM method to aggregate as a method group, instead of creating a lambda. So we end up with this:

public static ulong GetLowestCommonMultiple(ulong[] divisors)
{
return divisors.Aggregate(1UL, GetLowestCommonMultiple);
}

Quite a simple method, and we can now use that to find the answer to our original problem.

var answer = GetLowestCommonMultiple(new ulong[] { 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 });

Notice that I skip the numbers 1 to 10, since they are already “covered” in the numbers 11 to 20. With this solution it doesn’t really make much difference in the time taken though.

According to the StopWatch, this solution takes 0 milliseconds, or 522 ticks. Quite an improvement from over 30 seconds!

While writing this post I also discovered that I, of course, could get rid of that first LCM method all together by doing the LCM of two numbers inline, and marking the parameter as params. So, the resulting LCM method becomes this:

public static ulong GetLowestCommonMultiple(params ulong[] divisors)
{
return divisors.Aggregate(1UL, (a, b) => a / GetGreatestCommonDivisor(a, b) * b);
}

And that method does the work for both. All my test cases still run. Love it

Project Euler: Problem 3

Torleif — Thu, 17 Sep 2009 21:26:36 +0000

The third Euler problem has to do with prime factorization:

The prime factors of 13195 are 5, 7, 13 and 29.

What is the largest prime factor of the number 600851475143?

Solution

This one I struggled with a bit, cause I wasn’t sure exactly how to do this prime factorization. I knew what it was, and how to do it by hand, but wasn’t quite sure how to do it effective in code. Either way I ended up using something called the Sieve of Eratosthenes. Not the most efficient algorithm for this, if I have understood correctly, but it worked well enough for this use, and it was fairly straight forward to implement with some help from Black Wasp.

I started to make a prime number generator similar to the one I created for Fibonacci numbers in Problem 2.

public interface IPrimeSequence : IEnumerable<ulong> {}

public class Eratosthenes : IPrimeSequence
{
private readonly List<ulong> knownPrimes;

public Eratosthenes()
{
knownPrimes = new List<ulong> {2, 3};
}

#region IPrimeSequence Members
public IEnumerator<ulong> GetEnumerator()
{
// Return the ones we know first
foreach (var prime in knownPrimes)
yield return prime;

// Then find new ones
var possible = primes.Last();
while (true)
if (IsPrime(possible += 2))
{
yield return possible;
knownPrimes.Add(possible);
}
}

IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
#endregion

private bool IsPrime(ulong value)
{
var sqrt = (ulong) Math.Sqrt(value);
return !knownPrimes
.TakeWhile(x => x <= sqrt)
.Any(x => value%x == 0);
}
}

It basically starts with the 2 first primes. And for each new requested prime number, it goes through the following odd numbers until it finds one that is not dividable by any of the primes ones we know so far.

Note: I’ve created a separate post about the Sieve of Eratosthenes, which might be updated with some optimizations, et cetera

With that prime number generator in place, finding prime factors is pretty straight forward here.

public static IEnumerable<ulong> GetPrimeFactors(ulong value, IPrimeSequence primeSequence)
{
foreach (var prime in primeSequence)
{
while (value%prime == 0)
{
value /= prime;
yield return prime;
}

if (value == 1)
{
yield break;
}
}
}

Now, that is pretty much what is needed to solve this problem. A simple LINQ statement finds the answer.

var answer = GetPrimeFactors(600851475143, new Eratosthenes()).Max();

Tadaa

Geekality » Factorization

Project Euler: Problem 5

Solution

Project Euler: Problem 3

Solution