#### Introduction

Having spent a bit of time learning the basics of F# I decided to try my hands on actually writing some code and get a better feel of the language and get more used to writing function code in general. And for that purpose, Project Euler provides a great source for small, isolated problems well suited for a functional language like F#.

As of today there are a total of 300 questions, ordered in such a way that they’re progressively more difficult to solve, and whilst I’ll be posting my own answers written in F# you could just as easily solve these problems in a variety of languages.

#### Problem

So back to the first problem, here’s the brief:

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.

#### Solution

Here’s a one liner solution in F#:

let total = [1..999] |> List.map (fun i -> if i % 5 = 0 || i % 3 = 0 then i else 0) |> List.sum

Let me break down the solution a little, and go through it step by step.

I started off with** [1..999]** which is one of many ways you can create and initialize a new list in F#, doing this gives me a list with the values 1, 2, 3, … 998, 999, i.e. all the natural numbers below 1000.

**|>** is known as the forward pipe operator, it allows you to pass the result of the left side of the operator to the function on the right side. For a C# developer it is perhaps easier to simply think of it as chaining a couple of methods in a Linq query, e.g.

var total = Enumerable.Range(1, 999).Select(x => x % 3 == 0 || x % 5 == 0 ? x : 0).Sum();

The List.map function lets you apply a function to each element of a list and put all the results into a new list, as you’ve seen from the above C# code, it provides the same projection capability you get with the Enumerable.Select method in Linq.

In this particular case, I’m simply saying “for each element in the list, return the element if it’s a multiple of 3 or 5, otherwise return 0”, whilst this does not filter out the elements that are not multiples of 3 or 5 the final List.sum will simply ignore the zeros returned from the previous function.

You could equally use a predicate to filter out the elements which are not multiples of 3 or 5:

let total = [1..999] |> List.filter (fun i -> i % 5 = 0 || i % 3 = 0) |> List.sum

Notice that the List.filter works similar to the Enumerable.Where method in Linq.

var total = Enumerable.Range(1, 999).Select(x => x % 3 == 0 || x % 5 == 0 ? x : 0).Sum();

—————————————————————————error^——————-

Program.fs(4,81): error FS0618: Unexpected integer literal in type expression

Hi Bill, that line’s in C#, so it won’t compile as part of a F# module.

You can run it in LinqPad or a simple C# console app though, it’s basically the equivalent of the F# solution.

Thanks Bill. I used filter instead. Any difference in performance or otherwise?

[1..999]

|> List.filter (fun x -> x % 3 = 0 || x % 5 = 0)

|> List.sum

let mul5 = [5..5..999]

let mul3 = [3..3..999]

let sMul5 = List.sum mul5

let sMul3 = List.sum mul3

let total = sMul5 + sMul3

//Alternatively by yours

let total = [1..999] |> List.map (fun i -> if i%3 = 0 || i% 5 =0 then i else 0) |> List.sum

didnt match the value

because you’re doubling counting multiples of 15 when you sum the two lists that way

On a data set like this it won’t make any difference, but if you have a large data set and more complex projecting (e.g. filter -> filter -> filter -> map -> sum) then you might want to consider using Streams (https://github.com/nessos/Streams)

Pingback: APL - solving Euler problem 1 | theburningmonk.com

how about this?

List.fold (fun acc x -> acc + x) 0 [for i in 1..1000 do if i % 3 = 0 || i % 5 = 0 then yield i]

Sure, why not, it’s a valid alternative.

That said, List comprehension wouldn’t be my choice here since there’s a simple filter condition, I tend to use comprehensions in more complicated scenarios, like this one – https://gist.github.com/theburningmonk/33e38b347ae8c66392da

Also, you can simplify List.fold (fun acc x -> acc + x) 0 to List.reduce (+) here, but I would still personally go for List.sum as I find that more expressive of the intent (as in saying “sum the list” rather than “add elements together, starting 0/first elem as starting point”).

yeah makes sense. thanks Yan.