Factorials

Discussion in 'Ruby' started by Adam Trager, Jul 14, 2008.

  1. Adam Trager

    Adam Trager Guest

    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/.
    Adam Trager, Jul 14, 2008
    #1
    1. Advertising

  2. Adam Trager

    Serabe Guest

    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
    Serabe, Jul 14, 2008
    #2
    1. Advertising

  3. Adam Trager

    Victor Reyes Guest

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

    On Sun, Jul 13, 2008 at 8:04 PM, Serabe <> 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
    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
    Victor Reyes, Jul 14, 2008
    #3
  4. Adam Trager

    Dave Bass Guest

    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/.
    Dave Bass, Jul 14, 2008
    #4
  5. [Note: parts of this message were removed to make it a legal post.]

    On Mon, Jul 14, 2008 at 10:52 AM, Dave Bass <> 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
    http://talklikeaduck.denhaven2.com/
    Rick DeNatale, Jul 14, 2008
    #5
  6. Adam Trager

    Serabe Guest

    2008/7/14 Victor Reyes <>:

    > 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
    Serabe, Jul 14, 2008
    #6
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Phil Weldon

    Re: Factorials

    Phil Weldon, Sep 20, 2003, in forum: Python
    Replies:
    10
    Views:
    615
    Jacek Generowicz
    Sep 23, 2003
  2. Py-Fun

    Iteration for Factorials

    Py-Fun, Oct 22, 2007, in forum: Python
    Replies:
    66
    Views:
    1,493
    Gabriel Genellina
    Oct 31, 2007
  3. waldo

    factorials in C

    waldo, Oct 18, 2011, in forum: C Programming
    Replies:
    0
    Views:
    310
    waldo
    Oct 18, 2011
  4. waldo

    factorials and recursion

    waldo, Oct 18, 2011, in forum: C Programming
    Replies:
    0
    Views:
    220
    waldo
    Oct 18, 2011
  5. Thufir
    Replies:
    11
    Views:
    208
    Todd Benson
    Nov 8, 2007
Loading...

Share This Page