Yan Cui
I help clients go faster for less using serverless technologies.
This article is brought to you by
Don’t reinvent the patterns. Catalyst gives you consistent APIs for messaging, data, and workflow with key microservice patterns like circuit-breakers and retries for free.
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.
Whenever you’re ready, here are 3 ways I can help you:
- 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.
- 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.
- Join my community on Discord, ask questions, and join the discussion on all things AWS and Serverless.
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.