Project Euler Problem 9 introduces the interesting mathematical concept of Pythagorean Triple. Let’s have a look at the question:

A Pythagorean triplet is a set of three natural numbers, a < b < c, for which,
a² + b² = c²

For example, 3² + 4² = 9 + 16 = 25 = 5².

There exists exactly one Pythagorean triplet for which a + b + c = 1000.
Find the product abc.

As usual, I first show my solution and then comment on the approach:

#light

// generate triplets using Euclid's Formula
let pythagorean_triplets top =
    [ for m in 1 .. top do
          for n in 1 .. m-1 do
          let a = m*m-n*n
          let b = 2*m*n
          let c = m*m+n*n
          yield [a;b;c] ]

// multiply all the values of a list
let multiply_list list =
    List.fold (fun acc elem -> acc*elem) 1 list

// find a triplet where the sum of values
// is equal to a given number
let find_triplet_with_sum sum =
    pythagorean_triplets sum
    |> List.find (fun [a;b;c] -> a+b+c=sum)

let problem_9 () =
    find_triplet_with_sum 1000
    |> multiply_list

Let’s go through the solution step by step:

• The first function, pythagorean_triplets uses Euclid’s Formula to enumerate all possible Pytagorean Triplets up to a given threshold. The formula can be summarized like this:
  a = m² – n², b = 2mn, c = m² + n², where m and n are positive integers with m > n.

  It’s interesting to note that each item of the list is itself a list of three numbers. I could have generated a tuple, but since in the end I need to multiply all the 3 values together, the list was more straightfoward to use.

• multiply_list is just a convenience function to multiply all the elements of a list together
• find_triplet_with_sum does the heavy work of generating the actual triplets picking the first one where the sum is equal to a given value.
• At the end I just put the pieces together and solve the problem.

One caveat: Euclid’s Formula does not generate all Pytagorean Triplets(there are other formulas that do). I can say that I have been lucky that it generated the one requested by the Project’s Euler problem. The code above might not work if the goal is changed to find a triplet with a different product.

See all Project Euler problems solutions.

After two easy problems, it’s now time for Problem 8.

At first, this problem also seemed to me more complex than it really is. Let’s have a look at the question:

Find the greatest product of five consecutive digits in the 1000-digit number.

73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450

So, basically what we need to do is:

• consider all chunks of this list of numbers that can be created by taking 5 consecutive digits from the beginning till the end (there will be n-5 chunks if n is the number of digits in the list)
• for each chunk, multiply all the digits together (that’s n-1 products per chunk)
• pick the value corresponding to the greatest product.

At first I have considered resolving an easier problem first, like: find the chunk whose sum is bigger and then calculate that product. Assuming that sum is cheaper to calculate than product (and it is), we would have had (n-5) * (n-1) sums and just 1 product. However you can easily find examples where the sum of the digits is the same while the product is different: e.g. 4 + 5 = 7 + 2 = 9 but 4 * 5 = 20 > 7 * 2 = 14. Therefore that was a dead end.

A more mathematically sound approach to find the chunk giving the highest product might have been to first locate the chunk with the highest sum of logarithms of each digit and then calculate the corresponding product. However, a quick test revealed that logarithm is way slower than product.

Finally, a couple of micro-optimizations that occurred to me.

• You can skip all chunks containing at least one 0 (trivially, the product will be zero)
• You don’t really have to multiply all the digits for each chunk (that is (n-5) * (n-1) products): once you have computed the product of the first chunk, the product of the next chunk would be the product of the previous chunk times the sixth digit divided by the first digit, and so on for subsequent chunks.

Eventually, I did not try to implement these two things, since brute force, which I am about to show you, is so quick that it’s wasn’t really worth it:

#light

let digits = [| 7; 3; 1; 6; 7; 1; 7; 6; 5; 3; 1; 3; 3; 0; 6; 2; 4; 9;
    1; 9; 2; 2; 5; 1; 1; 9; 6; 7; 4; 4; 2; 6; 5; 7; 4; 7; 4; 2; 3; 5;
    5; 3; 4; 9; 1; 9; 4; 9; 3; 4; 9; 6; 9; 8; 3; 5; 2; 0; 3; 1; 2; 7;
    7; 4; 5; 0; 6; 3; 2; 6; 2; 3; 9; 5; 7; 8; 3; 1; 8; 0; 1; 6; 9; 8;
    4; 8; 0; 1; 8; 6; 9; 4; 7; 8; 8; 5; 1; 8; 4; 3; 8; 5; 8; 6; 1; 5;
    6; 0; 7; 8; 9; 1; 1; 2; 9; 4; 9; 4; 9; 5; 4; 5; 9; 5; 0; 1; 7; 3;
    7; 9; 5; 8; 3; 3; 1; 9; 5; 2; 8; 5; 3; 2; 0; 8; 8; 0; 5; 5; 1; 1;
    1; 2; 5; 4; 0; 6; 9; 8; 7; 4; 7; 1; 5; 8; 5; 2; 3; 8; 6; 3; 0; 5;
    0; 7; 1; 5; 6; 9; 3; 2; 9; 0; 9; 6; 3; 2; 9; 5; 2; 2; 7; 4; 4; 3;
    0; 4; 3; 5; 5; 7; 6; 6; 8; 9; 6; 6; 4; 8; 9; 5; 0; 4; 4; 5; 2; 4;
    4; 5; 2; 3; 1; 6; 1; 7; 3; 1; 8; 5; 6; 4; 0; 3; 0; 9; 8; 7; 1; 1;
    1; 2; 1; 7; 2; 2; 3; 8; 3; 1; 1; 3; 6; 2; 2; 2; 9; 8; 9; 3; 4; 2;
    3; 3; 8; 0; 3; 0; 8; 1; 3; 5; 3; 3; 6; 2; 7; 6; 6; 1; 4; 2; 8; 2;
    8; 0; 6; 4; 4; 4; 4; 8; 6; 6; 4; 5; 2; 3; 8; 7; 4; 9; 3; 0; 3; 5;
    8; 9; 0; 7; 2; 9; 6; 2; 9; 0; 4; 9; 1; 5; 6; 0; 4; 4; 0; 7; 7; 2;
    3; 9; 0; 7; 1; 3; 8; 1; 0; 5; 1; 5; 8; 5; 9; 3; 0; 7; 9; 6; 0; 8;
    6; 6; 7; 0; 1; 7; 2; 4; 2; 7; 1; 2; 1; 8; 8; 3; 9; 9; 8; 7; 9; 7;
    9; 0; 8; 7; 9; 2; 2; 7; 4; 9; 2; 1; 9; 0; 1; 6; 9; 9; 7; 2; 0; 8;
    8; 8; 0; 9; 3; 7; 7; 6; 6; 5; 7; 2; 7; 3; 3; 3; 0; 0; 1; 0; 5; 3;
    3; 6; 7; 8; 8; 1; 2; 2; 0; 2; 3; 5; 4; 2; 1; 8; 0; 9; 7; 5; 1; 2;
    5; 4; 5; 4; 0; 5; 9; 4; 7; 5; 2; 2; 4; 3; 5; 2; 5; 8; 4; 9; 0; 7;
    7; 1; 1; 6; 7; 0; 5; 5; 6; 0; 1; 3; 6; 0; 4; 8; 3; 9; 5; 8; 6; 4;
    4; 6; 7; 0; 6; 3; 2; 4; 4; 1; 5; 7; 2; 2; 1; 5; 5; 3; 9; 7; 5; 3;
    6; 9; 7; 8; 1; 7; 9; 7; 7; 8; 4; 6; 1; 7; 4; 0; 6; 4; 9; 5; 5; 1;
    4; 9; 2; 9; 0; 8; 6; 2; 5; 6; 9; 3; 2; 1; 9; 7; 8; 4; 6; 8; 6; 2;
    2; 4; 8; 2; 8; 3; 9; 7; 2; 2; 4; 1; 3; 7; 5; 6; 5; 7; 0; 5; 6; 0;
    5; 7; 4; 9; 0; 2; 6; 1; 4; 0; 7; 9; 7; 2; 9; 6; 8; 6; 5; 2; 4; 1;
    4; 5; 3; 5; 1; 0; 0; 4; 7; 4; 8; 2; 1; 6; 6; 3; 7; 0; 4; 8; 4; 4;
    0; 3; 1; 9; 9; 8; 9; 0; 0; 0; 8; 8; 9; 5; 2; 4; 3; 4; 5; 0; 6; 5;
    8; 5; 4; 1; 2; 2; 7; 5; 8; 8; 6; 6; 6; 8; 8; 1; 1; 6; 4; 2; 7; 1;
    7; 1; 4; 7; 9; 9; 2; 4; 4; 4; 2; 9; 2; 8; 2; 3; 0; 8; 6; 3; 4; 6;
    5; 6; 7; 4; 8; 1; 3; 9; 1; 9; 1; 2; 3; 1; 6; 2; 8; 2; 4; 5; 8; 6;
    1; 7; 8; 6; 6; 4; 5; 8; 3; 5; 9; 1; 2; 4; 5; 6; 6; 5; 2; 9; 4; 7;
    6; 5; 4; 5; 6; 8; 2; 8; 4; 8; 9; 1; 2; 8; 8; 3; 1; 4; 2; 6; 0; 7;
    6; 9; 0; 0; 4; 2; 2; 4; 2; 1; 9; 0; 2; 2; 6; 7; 1; 0; 5; 5; 6; 2;
    6; 3; 2; 1; 1; 1; 1; 1; 0; 9; 3; 7; 0; 5; 4; 4; 2; 1; 7; 5; 0; 6;
    9; 4; 1; 6; 5; 8; 9; 6; 0; 4; 0; 8; 0; 7; 1; 9; 8; 4; 0; 3; 8; 5;
    0; 9; 6; 2; 4; 5; 5; 4; 4; 4; 3; 6; 2; 9; 8; 1; 2; 3; 0; 9; 8; 7;
    8; 7; 9; 9; 2; 7; 2; 4; 4; 2; 8; 4; 9; 0; 9; 1; 8; 8; 8; 4; 5; 8;
    0; 1; 5; 6; 1; 6; 6; 0; 9; 7; 9; 1; 9; 1; 3; 3; 8; 7; 5; 4; 9; 9;
    2; 0; 0; 5; 2; 4; 0; 6; 3; 6; 8; 9; 9; 1; 2; 5; 6; 0; 7; 1; 7; 6;
    0; 6; 0; 5; 8; 8; 6; 1; 1; 6; 4; 6; 7; 1; 0; 9; 4; 0; 5; 0; 7; 7;
    5; 4; 1; 0; 0; 2; 2; 5; 6; 9; 8; 3; 1; 5; 5; 2; 0; 0; 0; 5; 5; 9;
    3; 5; 7; 2; 9; 7; 2; 5; 7; 1; 6; 3; 6; 2; 6; 9; 5; 6; 1; 8; 8; 2;
    6; 7; 0; 4; 2; 8; 2; 5; 2; 4; 8; 3; 6; 0; 0; 8; 2; 3; 2; 5; 7; 5;
    3; 0; 4; 2; 0; 7; 5; 2; 9; 6; 3; 4; 5; 0|]

let calculate_max_chunk_product chunk_size =
    seq {
        for i in 0 .. (Array.length digits - chunk_size) do
            let chunk = Array.sub digits i chunk_size
            yield Array.fold (fun acc elem -> acc * elem) 1 chunk
        }
    |> Seq.max

let problem_8 () =
    calculate_max_chunk_product 5

As you can see, we are generating a sequence of products and then pick the maximum value. Each product is created by first taking a chunk of the array (using the Array.sub) and then using Array.fold to compute the product of all elements in the chunk.

Again, I have tried to keep the imperative part to a minimum and I was able to get by without using any mutable variable.

See all Project Euler problems solutions.

Project Euler problem 6 is one of the easiest that I have encountered so far. Also, Problem 7 is quite easy to solve once you have a function for prime numbers (something we did in Problem 3). Therefore, in this post I give 2 problems for the price of 1!

Problem 6

Let’s have a look at the question for Problem 6:

The sum of the squares of the first ten natural numbers is,

1² + 2² + … + 10² = 385
The square of the sum of the first ten natural numbers is,

(1 + 2 + … + 10)² = 55² = 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.

There are a few tricks to calculate the sum of the squares (see for example here). However, given the limited size of the problem at hand, brute-force is perfectly fine: it shows once more the elegance of a declarative solution.

#light
open System

let square x = x * x

// a² + b²  + ... + z²
let sum_of_square max =
    Seq.unfold (fun x -> if x > max then None else Some(x*x, x+1)) 1
    |> Seq.sum

// (a +b + ... + z)²
let square_of_sum max =
    {1 .. max}
    |> Seq.sum
    |> square

let problem_6 max =
    square_of_sum(max) - sum_of_square(max)

Problem 7

By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.

What is the 10001st prime number?

As I mentioned in the introduction, this one is fairly easy once you know how to tell whether a given number is prime or not. We did that exercise in Problem 3.

There’s a catch though: this time we are counting the prime numbers. In the test we did in Problem 3 there was a small error that in that context was irrelevant: the test returned true also for 0 and 1, which strictly speaking are not prime numbers (2 is considered to be the first prime number).

For this reason, I have modified the code of is_prime a bit so that the first prime will be 2, the second 3, and so on as appropriate.

#light
open System

let is_prime x =
    let rec check i =
        x > 1L &&
       (double i > sqrt (double x) || (x % i <> 0L && check (i + 1L)))
    check 2L                 

let sequence_of_first_n_primes n =
    Seq.initInfinite (fun x -> int64 x)
    |> Seq.filter is_prime
    |> Seq.take n
    |> Seq.max

Ok… break time is over. Problem 8 looks a bit more challenging. See you when I have got a nice solution for that.

See all Project Euler problems solutions.

Yet another episode in my attempts to solve Project Euler problems.

Enter problem number 5:

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 positive number that is evenly divisible by all of the numbers from 1 to 20?

I’ll first show you my solution and then explain the bits:

#light

// greatest common divisor (Euclid Algorithm)
let rec gcd (a:int64, b:int64) =
    match b with
       | x when x = 0L -> a
       | _ -> gcd (b, a % b)

// least common divisor
let rec lcm (a:int64, b:int64) =
    (a * b) / gcd (a,b)

// least common divisor for a list of numbers
let rec lcmlist (list: int64 list) =
    match list with
        | [] -> 1L
        | [a] ->  a
        | [a;b] ->  lcm(a,b)
        | h::t  ->  lcm(h, lcmlist t)

// utility to generate a list of all integers
// up to a certain number
let generateListTo top =
    let l = [for i in 1L .. int64 top ->  i]
    l

let resolveProblem5 =
    generateListTo 20 |>  lcmlist

The first thing to realize when reading this problem is that what is really being asked is
the least common multiple (lcm from now on) of a list of numbers (in particular, the numbers from 1 to 20 included).

There’s a straightforward way to compute the lcm, by using the greatest common divisor (gcd), as follows:

As for the gcd itself, it can be easily implemented using the Euclid Algorithm.

The last piece of the puzzle comes when you realize how calculating the lcd of a set of numbers can be reduced to calculating lcds pair-wise in the following fashion:

For example, given the numbers 3, 4, 14, and 18, their lcm would be computed in the following way:

As you can see, the algorithm lends itself beautifully to recursion and such is the solution that I have provided.

See all Project Euler problems solutions.

Project Euler problem number 4 asks the following:

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.

Here follows my solution:

#light

open System

let rec is_palindromic (a:string) =
    let length = a.Length;
    match a with
        | ""  -> true
        | x -> match length with
                 | 1 -> true
                 | _ -> x.[0] = x.[length-1] &&
                       is_palindromic (x.Substring(1,(length - 2)))

let max_palindrome =
    let numbers = seq {
        for i in 100 .. 999 do
            for j in 100 .. 999 do
                if is_palindromic(Convert.ToString(i*j)) then yield (i*j) }
    Seq.max numbers

A few considerations:

• I first define a general recursive function to determine whether a given string is a palindrome.

  I basically check the first and last characters of the string; if they are the same I continue with the second and second last, and so on until I either found a pair of chars that do not match or there’s only one char or none left.

  Alternatively, I could have reversed the string and compared the original and reversed strings for equality; however that would have been not just more work than actually needed by the algorithm, but less useful as an excercise in learning F#.

• The actual algorithm uses brute force to test for palindromicity (neologism?) all the numbers that can be composed multiplying together 3 digits numbers (those from 100 to 999), picking the highest one. Again, as in a previous problem, I am using comprehension to generate a list of candidates.

See all Project Euler problems solutions.

Continuing with my journey learning F# I have tackled Project Euler problem number 3, which asks:

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

What is the largest prime factor of the number 600851475143

This problem deals with the fascinating problem of prime numbers factorization, which is considered a hard problem. So hard that our current cryptography schemes rely on this property.

This is my solution:

#light
open System

let is_prime x =
    let rec check i =
        double i > sqrt (double x) || (x % i <> 0L && check (i + 1L))
    check 2L                 

let big_number_factors n =
    let factors = seq {
        let limit = n / 2L
        for i in 2L .. limit do
            if n % i = 0L && is_prime i then yield i }
    Seq.max factors

A few comments:

• The first function (is_prime) is a simple trial division to determine whether a given number is prime. There are cleverer algorithms to find prime numbers: see for example here For an interesting discussion you can also have a look at The Genuine Sieve of Erathostenes by Melissa O’Neill.
• The second function uses comprehension to create the list of primes which are factors for the input value. At the end we simply return the biggest factor.

In my journey to learn F#, I have recently discovered the Project Euler site, which is a wonderful collection of small algorithmic problems which you can solve in your favorite programming language.

This is the kind of excercise I needed to get my feet wet with F# after reading about it. So I started with the first two problems listed on the site.

They both deal with sequence of numbers. Having a procedural/object-oriented mindset, I have scratched my head a few times in order to find a declarative solution true to the spirit of a functional program. Everything has become clearer after I’ve dug some more into the F# Sequences.

Problem 1

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.

This is my solution to it:

# light
let test = 1
    |> Seq.unfold (fun x -> Some(x, x+1))
    |> Seq.takeWhile (fun x -> x < 1000)
    |> Seq.filter ( fun x -> x % 3 = 0 || x % 5 = 0)
    |> Seq.sum;;

Problem 2

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.

Follows my solution:

# light
let fibonacci_sequence = Seq.unfold (fun (a, b) -> Some(a, (b, a+b))) (0,1)
    |> Seq.takeWhile(fun x -> x <= 400000)
    |> Seq.filter(fun x -> x % 2 = 0)
    |> Seq.sum

A few comments:

• Here I am using the filter method defined on sequences to stop
  the sequence itself at 4 million, therefore I can get by with plain integers. Normally you would want to use BigIntegers for sequences where you’d expect to need handling large numbers.
• One of my first attempts to this problem did not have the Seq.filter part. I only had the takeWhile like the following:

Seq.takeWhile(fun x -> x % 2 = 0 && x <= 400000)

Unfortunately, this does not work since the takeWhile will interrupt the sequence as soon as it satisfies the first condition (x % 2 = 0); in other words, it yields a sequence consisting only of the value 0, which looked somehow counterintuitive to me at first.

If you are also taking your first steps with F#, you might want to have a look to the best resources to learn it.

Floating Points and Rounding Errors.

Working with floating points number can sometimes provide some (un)pleasant surprise, since many real numbers do not have a finite representation and this can lead to rounding errors.

If you need to refresh your knowledge (and have some time to spare), you can find a great treatment in the article What Every Computer Scientist Should Know About Floating-Point Arithmetic:

Squeezing infinitely many real numbers into a finite number of bits requires an approximate representation. Although there are infinitely many integers, in most programs the result of integer computations can be stored in 32 bits. In contrast, given any fixed number of bits, most calculations with real numbers will produce quantities that cannot be exactly represented using that many bits. Therefore the result of a floating-point calculation must often be rounded in order to fit back into its finite representation. This rounding error is the characteristic feature of floating-point computation.

A small example should make the problem clearly visible:

class Program
{
    static void Main(string[] args)
    {
        double a = 22.4;
        double b = a / 131;

        double c = 0;
        for (int i = 0; i < 131; i++)
        {
            c += b;
        }

        Console.WriteLine("Are they equal?: {0}", a == c);
        Console.WriteLine("Difference (a - c) is {0} ", a - c);
    }
}

Here we are taking a double (a), diving it by 131 and then creating a new number (c) by adding the result of that division 131 times. By pure math, a and c should be equal. If you try this small program yourself, this is the output that you would get:

Are they equal?: False
Difference (a - c) is -4,9737991503207E-14

As you can see, the result is not what you might expect, and it's affected by a rounding error that is building up every time b is added to the partial result c.

Note that this is dependent on the number that I have chosen. If you substitute 131 with 5, you will not experience this problem.

Your Own Comparer

Sometimes this behavior might annoy you, especially when you don't need such a high precision and a “rough” equality is all you need. A typical situation is unit testing an algorithm against some expected result: your assertions may fail because of a rounding error, even though the logic of your algorithm is formally correct.

In such a case, you might want to implement your own comparer. A desirable property for such a comparer is a threshold value: if the difference between two floating points is below that threshold they are considered equal.

All you need is to implement the .NET interface IEqualityComparer interface.

class DoubleComparer : IEqualityComparer
{
    private readonly double threshold;

    public DoubleComparer(double threshold)
    {
        this.threshold = threshold;
    }

    public bool Equals(double x, double y)
    {
        return Math.Abs(x - y) < this.threshold;
    }

    public int GetHashCode(double obj)
    {
       return obj.GetHashCode();
    }
}

I have created my own comparer to use in my unit tests. I only have to implement 2 methods: Equals() and GetHashCode().

I don't care much for the actual algorithm of the hashcode implementation, so I am reusing double own algorithm.

Instead, I have applied my own logic to the Equals method: to me, two doubles are equal if the absolute value of their difference is within a given threshold (which I can pass to the comparer in the constructor).

The Comparer In Use

Suppose I have an algorithm to calculate the histogram of a given collection of doubles, and a unit test to validate the calculation against a collection of expected results.

In the example below, samples are the input values which I want to create the histogram for, and expectedBreaks is a sequence containing the left and right limits of the bins of the histogram (in the example I am requiring 5 bins, so the number of breaks is 5 + 1 = 6).

var p = new HistogramProvider();
double[] samples = { 20, 12, 4, 22, 19, 24, 9, 5, -12.2, 13, 0 };
double[] expectedBreaks = { -12.2, -4.96, 2.28, 9.52, 16.76, 24 };

var histogram = p.CreateHistogram(samples, 5);

Assert.IsTrue(expectedBreaks.SequenceEqual(
                       histogram.Breaks,
                       new DoubleComparer(0.01)));

I have figured out the threshold to pass (0.01) based on the relative size of the doubles under analysis. Of course, you should use your own judgement to come up with a sensible threshold according of the range of your input data.