# Euler's Journey Problem 1

So I decided to start a project where I gonna implement the same problem in many languages. I always wanted to compare how different programming languages face some coding challenges. I don’t want to prove that any language is better than other, althought I know that this kind of flame will happen. To have a organized list of problems I gonna use the Project Euler problems.

# First Problem: Multiples of 3 and 5

So the first step of this jorney is the Multiples of 3 and 5.

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.

And here are the may implementations:

## Java 1.8

``` Java SumMutiplesOf3And5 https://github.com/rogeralmeida/eulersjourney/blob/master/problems/1/java1.8/src/main/java/com/github/rogeralmeida/eulersjourney/SumMultiplesOf3And5.java package com.github.rogeralmeida.eulersjourney; /**

- Created by ralmeid on 12/25/14. */ public class SumMultiplesOf3And5 { public static void main(String… args){ Integer sum = 0; for(int number=1; number < 1000; number++){ if (number % 3 == 0 || number % 5 == 0){ sum += number; } } System.out.printf(“The sum of multiples of 3 and 5 below 1000 is %d”, sum); } } ``` Not much to say about the Java version. It is a little verbose, but still very easy to teach to programming students, as there’s no hidden concept here. Everything is very explicit.

## Scala

``` Scala Multiples https://github.com/rogeralmeida/eulersjourney/blob/master/problems/1/scala/src/Multiples.scala object Multiples { def main (args: Array[String]) { var number = 0; var sum = 0; for(number <- 1 to 999 if number % 3 == 0 || number % 5 == 0){ sum += number; } printf(“The sum of multiples of 3 and 5 bellow 1000 is %d”, sum); } }

```
I do not code in Scala, but have decided to add it to my toolbet in 2015. So I will make an effort to implement every problem in Scala as well.
I hope there's a less verbose way to do it in Scala, because I'm not happy with this code.
One point that I would like to highlight here is the way to create a [Range](http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Range) `1 to 999`. Also you can filter the for's enumerables without executing the for body.
---
Yes, I've found a better way of doing it in Scala. Check this out:
``` Scala Multiples https://github.com/rogeralmeida/eulersjourney/blob/master/problems/1/scala/src/Multiples.scala
object Multiples {
def main (args: Array[String]) {
val total = (1 to 999).toList.filter(number => number % 3 == 0 || number % 5 == 0).
reduce[Int]((accumulator, number) => accumulator+number)
printf("The sum of multiples of 3 and 5 bellow 1000 is %d", total);
}
}
```

First create a Range from 1 to 999. Then coarse it to a List. Then filter the list to get just the multiples of 3 or 5. Then reduce the list using a accumulator. I do liked this version, very concise, but the syntax is not that clear yet.

## Javascript

``` Javascript multiples.js https://github.com/rogeralmeida/eulersjourney/blob/master/problems/1/javascript/multiples.js var sum = 0; for(number = 1; number < 1000; number++){ if(number % 3 == 0 || number % 5 == 0){ sum += number; } } console.log(“The sum of multiples of 3 and 5 bellow 1000 is “+sum);

```
Not much to say here, very straightforward.
## Python 2
```Python multiples.py https://github.com/rogeralmeida/eulersjourney/blob/master/problems/1/python2/multiples.py
multiples = sum([number for number in range(1, 1000) if (number % 3 == 0) or (number % 5 == 0)])
print "The sum of multiples of 3 and 5 bellow 1000 is {}".format(multiples)
```

The more I touch Python, more I like it.
It uses the range function to generate the list of number from 1 to 999.
It uses List Comprehension to generate a list with only the multiples `[number for number in range(1, 1000) if (number % 3 == 0) or (number % 5 == 0)]`

then it uses the `sum()`

function to sum up the multiples.

## Ruby

```
Ruby mutiples.rb https://github.com/rogeralmeida/eulersjourney/blob/master/problems/1/ruby/multiples.rb
sum = (1..999).select{|number| number % 3 == 0 or number % 5 == 0}.reduce(:+)
puts "The sum of multiples of 3 and 5 is #{sum}"
```

My favorite version so far.
First I like the way to create the range `(1..999)`

. Like the Scala way it stills a little bit magical but this is it, or you have a Global function like Python or you have some sintax to recognize that you are creating a range.
The `select`

method is very useful to filter a collection. The `reduce`

method receives a symbol with the method that should be called to reduce the list, and it understand that it has to accumulate the value.