Although I’ve been learning Ruby and Rails for the past several months, I still feel like I need a better understanding of programming with respect to the more algorithmic side of things. While searching for resources last night, I came across Project Euler. Project Euler is a tool used to sharpen math skills through writing computer programs. In an effort to become really good at programming in Ruby, I’m going to try to solve a problem a week, and write about my thinking process behind the solution.

The following is the description of the problem:

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.

After looking through the Ruby documentation for methods to help me, I came up with this solution: ``` ruby problem1.rb def multiples sum = (1..999).select {|num| num % 3 == 0 || num % 5 == 0}.reduce(:+) puts sum end


First, we have to look at the range. Since the problem states that we have to find the sum of all the multiples BELOW 1000, the range has to be from <code>1..999</code>. At first, I used <code>1..1000</code> and couldn't understand why I kept getting a wrong answer when I submitted it. It helps to read the problem carefully.

The key to this solution is the <code>select</code> method. This method picks <code>num</code> out of the range with the criteria of being multiples of 3 or of 5. 

Once that those numbers are selected from the range, the <code>reduce</code> method adds them all up. When using the reduce method, all you have to do is specify the operation with a symbol, for example, <code>:+</code> is used for the addition of all the selected values.

Click [here]( to read more about the <code>select</code> method and [here]( to read more about the <code>reduce</code> method.


After I solved the problem, I looked at other peoples solutions on Project Euler to see how they went about it. I decided to compare the speed of my solution to that of another with Benchmark. Here's the other solution: 
``` ruby Other Solution
class MultipleSum
    def self.add_sums ( number )
      @belowNumber = number

    def self.add_multiples
      sum = 0
      find_multiples.each { |t| sum += t }
      return sum

    def self.find_multiples
      multiples =
      (1...@belowNumber).each do |value|
        multiples << value if value % 3 == 0 || value % 5 == 0
      return multiples

  puts MultipleSum.add_sums ( 1000 )

The other solution is a lot longer and in my opinion, less straightforward, so I expected mine to be faster. To my surprise, that wasn’t the case:

#My solution
0.000000   0.000000   0.000000 (  0.000205)

#Other solution
0.000000   0.000000   0.000000 (  0.000190)

Although it is slightly faster, the speed difference is negligible. I think that the shorter method is better simply for the sake of concise and clear code. If another developer needs a method like this(the chances are unlikely), a shorter method is more portable and easier to add into an existing project.