# Project Euler – Problem 1 Solution

Yan Cui

I help clients go faster for less using serverless technologies.

Table of Content

The real-time data platform that empowers developers to build innovative products faster and more reliably than ever before.

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

1. Production-Ready Serverless: Join 20+ AWS Heroes & Community Builders and 1000+ other students in levelling up your serverless game. This is your one-stop shop for quickly levelling up your serverless skills.
2. Do you want to know how to test serverless architectures with a fast dev & test loop? Check out my latest course, Testing Serverless Architectures and learn the smart way to test serverless.
3. I help clients launch product ideas, improve their development processes and upskill their teams. If you’d like to work together, then let’s get in touch.
4. Join my community on Discord, ask questions, and join the discussion on all things AWS and Serverless.

### 10 thoughts on “Project Euler – Problem 1 Solution”

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

2. theburningmonk

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.

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

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