# Project Euler: Problem #1

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

multiples()

```
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](http://www.ruby-doc.org/core-2.0.0/Array.html#method-i-select) to read more about the <code>select</code> method and [here](http://ruby-doc.org/core-2.0.0/Enumerable.html#method-i-reduce) to read more about the <code>reduce</code> method.
<h3>Comparison</h3>
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
add_multiples
end
def self.add_multiples
sum = 0
find_multiples.each { |t| sum += t }
return sum
end
def self.find_multiples
multiples = Array.new
(1...@belowNumber).each do |value|
multiples << value if value % 3 == 0 || value % 5 == 0
end
return multiples
end
end
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.