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.