2011 brings us yet another Project Euler problem to tackle: this time is Problem 18, one of the most interesting that I've solved so far:

By starting at the top of the triangle below and moving to adjacent numbers on the row below, the maximum total from top to bottom is 23.

3
7 4
2 4 6
8 5 9 3

That is, 3 + 7 + 4 + 9 = 23.

Find the maximum total from top to bottom of the triangle below:

75
95 64
17 47 82
18 35 87 10
20 04 82 47 65
19 01 23 75 03 34
88 02 77 73 07 63 67
99 65 04 28 06 16 70 92
41 41 26 56 83 40 80 70 33
41 48 72 33 47 32 37 16 94 29
53 71 44 65 25 43 91 52 97 51 14
70 11 33 28 77 73 17 78 39 68 17 57
91 71 52 38 17 14 91 43 58 50 27 29 48
63 66 04 68 89 53 67 30 73 16 69 87 40 31
04 62 98 27 23 09 70 98 73 93 38 53 60 04 23

NOTE: As there are only 16384 routes, it is possible to solve this problem by trying every route. However, Problem 67, is the same challenge with a triangle containing one-hundred rows; it cannot be solved by brute force, and requires a clever method! ;o)

Analysis

This problem is easily solved resorting to dynamic programming, which we can loosely describe as decomposing the overall problem into easier sub-problems and combining their solutions to find the final answer.

In our case, if we consider the number associated with each node of the triangle as a cost, the overall problem can be expressed as finding the path with maximum cost from the upper vertex to the bottom row. A generic sub-problem would be the cost to reach the bottom row from a generic node at position i,j.

Given the cost of passing through a given node and the cost of reaching the bottom row from that particular node, we can define the following truth:

or, in other words, from each node i,j the cost of reaching the bottom is equal to the cost of the node itself plus the maximum path between one of the two adjacent nodes from the row below.

Let's confirm why this is the case with the help of the following figure: consider for example the first node from the left in the fourteenth (last-but-one) row (having cost 63): from there you can move to the bottom either going to node 04 or node 62. Clearly, if we want to pick the highest cost, we need to pick 62 (and we mark this choice with a grey line). The overall cost to reach the bottom from that node is thus 63 + max (04, 62) = 125.

Let’s consider now the second node from that row (66). From there, we have to choose between node 62 and 98: the highest cost path from there is thus 66 + max(62, 98) = 164. We can continue for all the nodes in the row to find the highest cost path from each node; the solution to such sub-problems is indicated in gray close to each node.

Having solved all sub-problems for row 14, we can now consider the row immediately above. In the following figure, I have replaced row 14 with the solutions of the sub-problems that we had just solved; the row above is row 13. Please note how we don’t care about row 15 anymore: its contribution to the overall problem is already captured in each sub-problems’ solution for row 14! Hence, we proceed in a similar way to solve the sub-problems for the row 13 just as we did for row 14:

We continue to follow a similar pattern moving upwards row after row, until we reach the tip of the triangle, always considering two rows at a time.

Solution

#light

let a = Array2D.zeroCreate<int> 15 15

a.[0,0] <- 75
a.[1,0] <- 95
a.[1,1] <- 64
a.[2,0] <- 17
a.[2,1] <- 47
a.[2,2] <- 82
a.[3,0] <- 18
// other initializations omitted for clarity
// full listing available on Github
// (https://github.com/stefanoric/YAPEFSHARP)
a.[14,10] <- 38
a.[14,11] <- 53
a.[14,12] <- 60
a.[14,13] <- 04
a.[14,14] <- 23 

let costs = Array2D.zeroCreate<int> 15 15

// costs for bottom row is the same as bottom row values
Array2D.blit a 14 0 costs 14 0 1 15 |> ignore

let max a b = if a > b then a else b

for i in 13 .. -1 .. 0 do
    for j in 0 .. i do
        costs.[i,j] <- a.[i,j] + max costs.[i+1,j] costs.[i+1, j+1]

let result () =
    costs.[0,0]

Most of the code for this solution is needed just to initialize the two dimensional array containing the triangle. For reading convenience, I have skipped most of the uninteresting rows, but you can find the complete solution on Github.

So, we have a matrix (2D array) for the cost of each nodes and another matrix for the solutions of the sub-problems associated to each node. Trivially, the costs and the solutions coincide for the bottom row (note the handy Array2D.blit function to copy a whole row from one matrix to the other).

Then, with a loop we move backward from the last-but-one row up to the tip of the triangle calculating the sub-problems solutions as explained above.

Project Euler problem 17 turned out to be quite an easy one.

If the numbers 1 to 5 are written out in words: one, two, three, four, five, then there are 3 + 3 + 5 + 4 + 4 = 19 letters used in total.

If all the numbers from 1 to 1000 (one thousand) inclusive were written out in words, how many letters would be used?

NOTE: Do not count spaces or hyphens. For example, 342 (three hundred and forty-two) contains 23 letters and 115 (one hundred and fifteen) contains 20 letters. The use of "and" when writing out numbers is in compliance with British usage.

Solution

The solution this time is almost trivial:

• "Zero" is considered to have 0 length (it will be obvious later on why this is the case)
• Numbers from 1 to 19 have their own unique names (i.e. they are not composed by putting together more words)
• Numbers from 20 to 99 are combined putting together a word like "thirty" and a number from 0 to 9. If the number is zero, we don't add anything (we don't say "twenty and zero")
• Numbers from 100 to 999 are combined putting together a words like "two hundred and" plus a number from 0 to 99 composed as explained above. Exact multiples of 100 are exception in that they don't have another trailing number (again, we don't say "two hundred and zero").

#light

let thousand    = "oneThousand"
let hundred     = "hundred"
let hundred_and = "hundredAnd"

let zero_to_nine = new System.Collections.Generic.Dictionary<int, string="">()
zero_to_nine.[0] <- ""
zero_to_nine.[1] <- "one"
zero_to_nine.[2] <- "two"
zero_to_nine.[3] <- "three"
zero_to_nine.[4] <- "four"
zero_to_nine.[5] <- "five"
zero_to_nine.[6] <- "six"
zero_to_nine.[7] <- "seven"
zero_to_nine.[8] <- "eight"
zero_to_nine.[9] <- "nine"

let ten_to_nineteen =  new System.Collections.Generic.Dictionary<int, string="">()
ten_to_nineteen.[10] <- "ten"
ten_to_nineteen.[11] <- "eleven"
ten_to_nineteen.[12] <- "twelve"
ten_to_nineteen.[13] <- "thirteen"
ten_to_nineteen.[14] <- "fourteen"
ten_to_nineteen.[15] <- "fifteen"
ten_to_nineteen.[16] <- "sixteen"
ten_to_nineteen.[17] <- "seventeen"
ten_to_nineteen.[18] <- "eighteen"
ten_to_nineteen.[19] <- "nineteen"

let twenty_to_ninety = new System.Collections.Generic.Dictionary<int, string="">()
twenty_to_ninety.[20] <- "twenty"
twenty_to_ninety.[30] <- "thirty"
twenty_to_ninety.[40] <- "forty"
twenty_to_ninety.[50] <- "fifty"
twenty_to_ninety.[60] <- "sixty"
twenty_to_ninety.[70] <- "seventy"
twenty_to_ninety.[80] <- "eighty"
twenty_to_ninety.[90] <- "ninety"

let len s = String.length s

let calculate_letters_under_one_hundred n =
    match n with
        | x when x < 10 -> len zero_to_nine.[x]
        | x when x < 20 -> len ten_to_nineteen.[x]
        | x when x < 100 -> len twenty_to_ninety.[((x / 10) * 10)] + len zero_to_nine.[(x % 10)]
        | _ -> failwith "Number is too big!"

let calculate_letters n =
    match n with
        | x when x < 100 -> calculate_letters_under_one_hundred x
        | x when ((x < 1000) && (x % 100 = 0)) -> len zero_to_nine.[(x / 100)] + len hundred
        | x when x < 1000 -> len zero_to_nine.[(x / 100)] + len hundred_and +  calculate_letters_under_one_hundred (x % 100)
        | 1000 -> len thousand
        | _ -> failwith "Numer is too big!"

let all_letters_up_to n =
    List.sumBy (fun i -> calculate_letters i) [1..n]

It’s time for another Project Euler exercise. This time around it’s problem 16:

2¹⁵ = 32768 and the sum of its digits is 3 + 2 + 7 + 6 + 8 = 26.

What is the sum of the digits of the number 2¹⁰⁰⁰?

Analysis

I have tried to found an elegant way to solve this problem at a mathematical level, but I couldn't gain any insight relating powers of 2 to their representation in base 10 (I'd love to know if such a thing exists). Therefore I resorted to solve this problem with brute force.

Luckily F# (and now all other .NET 4.0 cousin languages) sports the BigInteger numeric type which helps tackling such huge numbers.

There are basically two approaches to solve this problem:

• Transform the result of exponentiation into a string and iterate through the string adding up all the individual digits, or
• Do without strings, and decompose the big number into the individual digits on my own.

I have decided to take the second route because it seemed like a more interesting exercise (the first approach could probably lead to a one-liner). ^[1].

Let’s consider a generic number n and consider how we can describe it as a sum of powers of 10:

For example

and k = 2, d₀ = 3, d₁ = 2, and d₂ = 4

So, given a generic number n, we need to find the highest power of ten ( k ) such that

(logarithms will help us there). After k is found, we can start diving n by 10^k to find d_k and use the reminder of the division to calculate d_k-1 and so forth until we reach d₀.

Solution

#light

open System
open System.Numerics

let rec decompose_rec n power_of_ten accu =
    match power_of_ten with
        | i when i = 1I -> accu @ [n]
        |_ ->
            let d = n / power_of_ten
            let digits = accu @ [d]
            decompose_rec (n - (d * power_of_ten)) (power_of_ten / 10I) digits

let decompose n =
    let power = floor (log10 (float n))
    let initial_power_of_ten = BigInteger.Pow(10I, int32 power)
    decompose_rec n initial_power_of_ten []

let sum_digits n =
    decompose n |> List.sum

1. ^[1] A recruiter for a very big company once asked me something very similar during an interview as a coding exercise ↩

After a brief digression with an RPN Calculator, here we are again with a new Project Euler problem:

The sequence of triangle numbers is generated by adding the natural numbers.

So the 7^(th) triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28.

The first ten terms would be:
1, 3, 6, 10, 15, 21, 28, 36, 45, 55, …

Let us list the factors of the first seven triangle numbers:

1: 1
3: 1,3
6: 1,2,3,6
10: 1,2,5,10
15: 1,3,5,15
21: 1,3,7,21
28: 1,2,4,7,14,28

We can see that 28 is the first triangle number to have over five divisors.

What is the value of the first triangle number to have over five hundred divisors?

Again, this problem is relatively simple to solve and it's about finding an algorithm with decent performances.

The naive (slow) solution

#light

let triangles =
    Seq.unfold (fun (acc, state) -> Some (acc, (state + acc, state + 1))) (0, 1)
    |> Seq.skip 1 // skip the initial 0

let divides y x =
    x % y = 0

let rec all_factors_slow_rec n i acc =
    match i with
        | 1 -> 1::acc
        | x when divides x n -> all_factors_slow_rec n (x-1) (x::acc)
        | _ -> all_factors_slow_rec n (i-1) acc

let all_factors_slow n =
    all_factors_slow_rec n n []

let find_index m =
    triangles
    |> Seq.map all_factors_slow
    |> Seq.tryFindIndex (fun x -> List.length x >= m)

let resolve_problem_12 =
    let i = find_index 500
    match i with
        | None -> failwith "Cannot resolve problem"
        | Some(i) ->
            let list = triangles |> Seq.take (i+1) |> List.ofSeq
            list.[i]

• Considering that triangle numbers are a mathematical sequence defined as follows:
  where , then we easily define an F# sequence that yields triangle numbers using Seq.unfold.
• We then define a function all_factors_slow_rec to calculate all factors (not just primes) of a given number. The slow solution presented in the first listing starts from a number n and then by brute force tries all the numbers down to 1 as a candidate factor.
• Once we have these two pieces together, it's just a matter of enumerating all possible triangle numbers, finding for each their factors (using Seq.map) and finally determining the first triangle number having at least 500 factors (using Seq.tryFindIndex). If is the index of such a number, we then go back to the original sequence of triangles to extract the element.

An improved version

#light

let divides y x =
    x % y = 0

let triangles =
    Seq.unfold (fun (acc, state) -> Some (acc, (state + acc, state + 1))) (0, 1)
    |> Seq.skip 1 // skip the initial 0

let rec all_factors_quick_rec n i factors =
    if divides i n then
        let y = n / i
        if (i < y) then
            all_factors_quick_rec n (i + 1) (i::y::factors)
        elif (i = y) then
            // we have reached the square root value
            i::factors
        else
            factors
    elif i > int (sqrt (float n)) then
        // we are beyond the square root value
        factors
    else
        // try with the next number
        all_factors_quick_rec n (i + 1) factors

let all_factors_quick n =
    all_factors_quick_rec n 1 []

let find_index m =
    triangles
    |> Seq.map all_factors_quick
    |> Seq.tryFindIndex (fun x -> List.length x >= m)

let resolve_problem_12 =
    let i = find_index 500
        match i with
        | None -> failwith "Cannot resolve problem"
        | Some(i) ->
            let list = triangles |> Seq.take (i+1) |> List.ofSeq
            list.[i]

The bottleneck of the previous solution is the naive approach to find all the factors of a number. On my machines this solution takes several minutes.

Better performances can be obtained observing that in order to determine all the factors of a number we don't have try all smaller numbers. As a matter of fact, the following is true (considering n the number to be factorized):

• if , obviously both x and y are factors, so I don't have to probe y anymore
• If I start probing from 2 going up, I can stop probing when I have reached . In fact, any number bigger than must have been already found probing a smaller number.

Suppose for example that we have to factor the number 36 (one of the triangle numbers):

• 1 is always a factor -> factors = {1, 36}
• 2 * 18 = 36 -> factors = {1, 36, 2, 18}
• 3 * 12 = 36 -> factors = {1, 36, 2, 18, 3, 12 }
• 4 * 9 = 36 -> factors = {1, 36, 2, 18, 3, 12, 4, 9}
• 5 does not divide -> factors = {1, 36, 2, 18, 3, 12, 4, 9}
• 6 * 6 = 36 -> factors = {1, 36, 2, 18, 3, 12, 4, 9, 6}

We can stop here because if 7 divided 36 evenly, we would have already found a number x < 6 such that 7 * x = 36.

The improved version runs on my machine in less than 1 second.

See all Project Euler problems solutions.

While continuing my journey in F#, after playing with Project Eulero problems for a few weeks, I have come across another excellent  excercise site which goes under the name of Programming Praxis.

The first exercise requires to implement a simple calculator using Reverse Polish Notation (RPN).

Here follows a simple solution to the problem. Operands are pushed onto the stack until an operator is found: at that point the last two operands are popped from the stack, the operator is applied to them and the result is pushed back on the stack.

#light

let is_operator c =
    match c with
        | "+" | "-" | "*" | "/"  -> true
        | _ -> false

let calculate left operator right =
    match operator with
        | "+" -> left + right
        | "-" -> left - right
        | "*" -> left * right
        | "/" -> left / right
        | _ -> failwith "Unknown operator"

let proc (item:string) (stack:System.Collections.Generic.Stack<double>) =
    if is_operator item then
        let r = stack.Pop()
        let l = stack.Pop()
        let result = calculate l item r
        stack.Push result
    else
        stack.Push(System.Convert.ToDouble(item))

let evaluate (expression:string) =
    let stack = new System.Collections.Generic.Stack<double>()
    let items = expression.Split([|' ' |])
    Array.iter (fun i -> proc i stack) items
    stack.Pop()

• We first define a simple function to check whether a given string is to be interpreted as an arithmetic operand. As you can see, we only support basic operators, nothing too fancy.
• We then define a function which takes a double, a string (representing an operator) and another double, and returns the result of applying the given operator to the two numbers.
• The proc function takes a string, which represent either an operand or an operator, and a stack of operands.
  If the item contained in the string is an operator, two operands are popped from the stack: the first pop is for the right side operand and the second pop is for the left operand; hence, the operator is applied to the two operands and the result is pushed back onto the stack.
  Otherwise, if it's an operand, it's first converted from the string format and pushed onto the stack.
• Finally, the entrance point to the program is defined with the evaluate function, which
  • accepts a string containing the overall expression (such as "1 2 + 4 / 5 * 6 -")
  • splits the string into an array of token strings
  • feed each token into the proc function
  • finally pops the stack with the last operand to yield the result of the operation.

Project Euler Problem 11 is an interesting one; when addressed with a functional approach it lends itself to be solved using function composition. Let's have a look at the question and then a possible solution:

In the 20×20 grid below, four numbers along a diagonal line have been marked in red. 08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00 81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65 52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91 22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80 24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50 32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70 67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21 24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72 21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95 78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92 16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57 86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58 19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40 04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66 88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69 04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36 20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16 20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54 01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48 The product of these numbers is 26 × 63 × 78 × 14 = 1788696. What is the greatest product of four adjacent numbers in any direction (up, down, left, right, or diagonally) in the 20×20 grid?

#light

let numbers =
    array2D [|
      [|08;02;22;97;38;15;00;40;00;75;04;05;07;78;52;12;50;77;91;08|];
      [|49;49;99;40;17;81;18;57;60;87;17;40;98;43;69;48;04;56;62;00|];
      [|81;49;31;73;55;79;14;29;93;71;40;67;53;88;30;03;49;13;36;65|];
      [|52;70;95;23;04;60;11;42;69;24;68;56;01;32;56;71;37;02;36;91|];
      [|22;31;16;71;51;67;63;89;41;92;36;54;22;40;40;28;66;33;13;80|];
      [|24;47;32;60;99;03;45;02;44;75;33;53;78;36;84;20;35;17;12;50|];
      [|32;98;81;28;64;23;67;10;26;38;40;67;59;54;70;66;18;38;64;70|];
      [|67;26;20;68;02;62;12;20;95;63;94;39;63;08;40;91;66;49;94;21|];
      [|24;55;58;05;66;73;99;26;97;17;78;78;96;83;14;88;34;89;63;72|];
      [|21;36;23;09;75;00;76;44;20;45;35;14;00;61;33;97;34;31;33;95|];
      [|78;17;53;28;22;75;31;67;15;94;03;80;04;62;16;14;09;53;56;92|];
      [|16;39;05;42;96;35;31;47;55;58;88;24;00;17;54;24;36;29;85;57|];
      [|86;56;00;48;35;71;89;07;05;44;44;37;44;60;21;58;51;54;17;58|];
      [|19;80;81;68;05;94;47;69;28;73;92;13;86;52;17;77;04;89;55;40|];
      [|04;52;08;83;97;35;99;16;07;97;57;32;16;26;26;79;33;27;98;66|];
      [|88;36;68;87;57;62;20;72;03;46;33;67;46;55;12;32;63;93;53;69|];
      [|04;42;16;73;38;25;39;11;24;94;72;18;08;46;29;32;40;62;76;36|];
      [|20;69;36;41;72;30;23;88;34;62;99;69;82;67;59;85;74;04;36;16|];
      [|20;73;35;29;78;31;90;01;74;31;49;71;48;86;81;16;23;57;05;54|];
      [|01;70;54;71;83;51;54;69;16;92;33;48;61;43;52;01;89;19;67;48|];
      |]

let dimensions = (Array2D.length1 numbers, Array2D.length2 numbers)

let horizontal_traverser (i, j) (iMax, jMax) f_4 =
    if (i > iMax) || (j + 4> jMax) then 0
    else f_4 numbers.[i,j]  numbers.[i, j+1] numbers.[i,j+2] numbers.[i,j+3]

let vertical_traverser (i,j) (iMax, jMax) f_4 =
    if (i + 4 > iMax) || (j > jMax) then 0
    else f_4 numbers.[i,j] numbers.[i+1, j] numbers.[i+2, j] numbers.[i+3,j]

let diagonal_traverser_left_right (i, j) (iMax, jMax) f_4 =
    if (i + 4 > iMax) || (j + 4 > jMax) then 0
    else f_4 numbers.[i,j] numbers.[i+1, j+1] numbers.[i+2, j+2] numbers.[i+3,j+3]

let diagonal_traverser_right_left (i, j) (iMax, jMax) f_4 =
    if (i - 3 < 0) || (j + 4 > jMax) then 0
    else f_4 numbers.[i,j] numbers.[i-1, j+1] numbers.[i-2, j+2] numbers.[i-3,j+3]

let max_in_direction traverser f_4 =
    seq { for i in 0..fst dimensions - 1 do
              for j in 0..snd dimensions - 1 do
                  yield traverser (i,j) dimensions f_4 }
    |> Seq.max

let maximum f_4 =
    [| max_in_direction horizontal_traverser f_4;
       max_in_direction vertical_traverser f_4;
       max_in_direction diagonal_traverser_left_right f_4;
       max_in_direction diagonal_traverser_right_left f_4 |]
    |> Array.max

let problem_11 () =
    maximum (fun a b c d -> a * b * c * d)

• We first declare a two-dimensions array containing the 20×20 numbers that we need to explore. To do this we use F# Array2D Module. The same module is used also to compute a tuple containing the size of the two dimension arrays, which we'll use later on.
• We then proceed to define four traverser functions, one for each of these directions: horizontal, vertical, diagonal top-left to bottom-right and diagonal bottom-left to top-right. Each traverser takes as input a given item of the array and applies the supplied 4-parameters function to the starting item plus the next 3 items in a direction. Note how at this point we are not talking about a specific operation (product or sum) yet and we are concentrating on 4 items of the array at a time.
• Next we define the max_in_direction function that takes a traverser and a 4-parameters function and finds the maximum value in that particular direction (whatever it might be applying the given function).
• We are getting closer to the solution by defining the maximum one-dimension array, where each item is the maximum value in each of the four directions and then taking the highest one.
• We finally solve the problem by invoking the maximum function passing to it the product of four items as a lambda.

Note how easy it is to change the particular function that we use to aggregate the 4 items: suppose for example that we are interested in the 4 items giving the maximum sum, we could simply invoke:

maximum (fun a b c d -> a + b + c + d)

See all Project Euler problems solutions.

Project Euler Problem 10 asks a very simple question, again dealing with prime numbers:

Calculate the sum of all the primes below two million.

I am giving here two solutions, using two different approaches:

#light

open System.Collections.Generic

// SOLUTION 1: TRIAL DIVISION
let is_prime (x:int64) =
    let rec check i =
        double i > sqrt (double x) || (x % i <> 0L && check (i + 1L))
    check 2L  

let trial_division (n:int64) =
    seq { for i in 2L .. n do
          if is_prime i then yield i }
    |> Seq.takeWhile (fun x -> x < n)
    |> Seq.sum

// SOLUTION 2: USE THE SIEVE
let sieve (n:int64) =
    let candidatePrimes = new Dictionary<int64, bool>()
    for i in 2L .. n do candidatePrimes.Add(i, true)
    for i in 2L .. n/2L do
        if candidatePrimes.[i] = true then
            let mutable j = i
            while (j + i <= n) do
                j <- j + i
                candidatePrimes.[j] <- false
    seq { for i in 2L .. n do
            if candidatePrimes.[i] = true then
                yield i }
    |> Seq.sum

• The first solution uses trial division to create a sequence of all primes under a certain threshold. It's the easiest method to understand.
• The second solution is a naive implementation of the Sieve of Erathostenes. I first mark all the numbers as candidate primes; then starting from 2 I mark off all the multiples, move to the next candidate prime, until only primes are left (you can refer to the Wikipedia article for all the details).

  As you can see, this second solution looks has a more imperative feel to it, using mutable data (a dictionary and a counter). Based on my tests for numbers from 1 to 10 millions, it's at least twice as fast as the trial division method.

See all Project Euler problems solutions.

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.