#### 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.

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