Project Euler – Problem 1 Solution

Yan Cui

I help clients go faster for less using serverless technologies.

This article is brought to you by

Hookdeck: The Serverless Event Gateway

Hookdeck is a reliable and scalable serverless event gateway for sending, receiving, authenticating, transforming, filtering, and routing events between services in your event-driven architecture.

Learn more


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.


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.


Here’s a one liner solution in F#:

let total = [1..999] |> (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 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.

Whenever you’re ready, here are 4 ways I can help you:

  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();

    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?


    |> 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] |> (fun i -> if i%3 = 0 || i% 5 =0 then i else 0) |> List.sum

    didnt match the value

  5. Pingback: APL - solving Euler problem 1 |

  6. 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]

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

    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”).

Leave a Comment

Your email address will not be published. Required fields are marked *