Velocity Reviews > Ruby > Factorials

# Factorials

Guest
Posts: n/a

 07-13-2008
I just started using ruby, and no matter how hard i try i cant do
factorials. how to a get the factorial of an imported number?
--
Posted via http://www.ruby-forum.com/.

Serabe
Guest
Posts: n/a

 07-14-2008
The easy way:

def factorial(n)
if n==1
1
else
n*factorial(n-1)
end
end

puts factorial(5)

It prints 120.

A more ruby way method:

def factorial(n)
(1..n).inject(1) {|product, n| product * n }
end

puts factorial(5)

It does also print 120.

Regards,

Serabe

--
http://www.serabe.com

Victor Reyes
Guest
Posts: n/a

 07-14-2008
[Note: parts of this message were removed to make it a legal post.]

On Sun, Jul 13, 2008 at 8:04 PM, Serabe <(E-Mail Removed)> wrote:

> The easy way:
>
> def factorial(n)
> if n==1
> 1
> else
> n*factorial(n-1)
> end
> end
>
> puts factorial(5)
>
> It prints 120.
>
> A more ruby way method:
>
> def factorial(n)
> (1..n).inject(1) {|product, n| product * n }
> end
>
> puts factorial(5)
>
> It does also print 120.
>
> Regards,
>
> Serabe
>
> --

> http://www.serabe.com
>
>

The "Rubish" version of your factorial solutions appear to be much faster!
Although I find it more confusing than the "traditional" recursive solution.
I guess my problem is understanding the role of the *inject* method.
I use 100 instead of 5 to make it run a bit longer.

def factorial(n)
if n==1
1
else
n*factorial(n-1)
end
end

puts factorial(100)

timex ruby factorial01
93326215443944152681699238856266700490715968264381 62146859296389521759999322991560894146397615651828 62536979208272237582511852109168640000000000000000 00000000

real 0.05
user 0.00
sys 0.00
================================================== ==
def factorial(n)
(1..n).inject(1) {|product, n| product * n }
end

puts factorial(100)

timex ruby factorial02
93326215443944152681699238856266700490715968264381 62146859296389521759999322991560894146397615651828 62536979208272237582511852109168640000000000000000 00000000

real 0.02
user 0.00
sys 0.00

Regards,

Victor

Dave Bass
Guest
Posts: n/a

 07-14-2008
Victor Reyes wrote:
> I guess my problem is understanding the role of the *inject* method.

Same problem here. But I figured out it's ideal for calculating
summations and products, where you'd use a big Sigma or Pi in
mathematics.

Surprisingly Fortran never had Sigma or Pi constructs; we had to roll
our own using a DO loop. Same for subsequent languages. Ruby is the
first language I've come across with it built in.

Maybe someone would explain why it's called "inject" though?

Dave
--
Posted via http://www.ruby-forum.com/.

Rick DeNatale
Guest
Posts: n/a

 07-14-2008
[Note: parts of this message were removed to make it a legal post.]

On Mon, Jul 14, 2008 at 10:52 AM, Dave Bass <(E-Mail Removed)> wrote:

> Victor Reyes wrote:
> > I guess my problem is understanding the role of the *inject* method.

>
> Same problem here. But I figured out it's ideal for calculating
> summations and products, where you'd use a big Sigma or Pi in
> mathematics.
>
> Surprisingly Fortran never had Sigma or Pi constructs; we had to roll
> our own using a DO loop. Same for subsequent languages. Ruby is the
> first language I've come across with it built in.
>
> Maybe someone would explain why it's called "inject" though?
>

I believe that Matz took the name from Smalltalk, where the equivalent to
Ruby's

collection.inject(0) {|sum, element| sum + element }

would be:

collection inject: 0 into: [sum, element | sum + element]

The idea is that this method 'injects' the first value into the sequence,
which is handy in some cases.

This is an 'enhanced' version of what is called reduce in many other
functional and functional-influenced languages. Ruby allows the injection
argument to be omitted in the call, which makes the name a bit more
mysterious. Without the injection argument Ruby's inject works just like
reduce, and Ruby 1.9 makes reduce an alias for inject.

--
Rick DeNatale

My blog on Ruby

Serabe
Guest
Posts: n/a

 07-14-2008
2008/7/14 Victor Reyes <(E-Mail Removed)>:

> The "Rubish" version of your factorial solutions appear to be much faster!
> Although I find it more confusing than the "traditional" recursive solution.
> I guess my problem is understanding the role of the *inject* method.
> I use 100 instead of 5 to make it run a bit longer.

Copied from ri documentation for Enumerable#inject:

------------------------------------------------------ Enumerable#inject
enum.inject(initial) {| memo, obj | block } => obj
enum.inject {| memo, obj | block } => obj
------------------------------------------------------------------------
Combines the elements of _enum_ by applying the block to an
accumulator value (_memo_) and each element in turn. At each step,
_memo_ is set to the value returned by the block. The first form
lets you supply an initial value for _memo_. The second form uses
the first element of the collection as a the initial value (and
skips that element while iterating).

# Sum some numbers
(5..10).inject {|sum, n| sum + n } #=> 45
# Multiply some numbers
(5..10).inject(1) {|product, n| product * n } #=> 151200

# find the longest word
longest = %w{ cat sheep bear }.inject do |memo,word|
memo.length > word.length ? memo : word
end
longest #=> "sheep"

# find the length of the longest word
longest = %w{ cat sheep bear }.inject(0) do |memo,word|
memo >= word.length ? memo : word.length
end
longest #=> 5

Regards,

Serabe

--
http://www.serabe.com