# 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

```
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

```
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 `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:

```
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

```
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

```
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

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