Factorials

[Adam Trager]

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?

 

[Serabe]

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

 

[Victor Reyes]

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

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

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
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

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
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

real 0.02
user 0.00
sys 0.00


Regards,

Victor

 

[Dave Bass]

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

 

[Rick DeNatale]

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

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.

 

[Serabe]

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