Forum: Ruby ruby beats them all

Announcement (2017-05-07): www.ruby-forum.com is now read-only since I unfortunately do not have the time to support and maintain the forum any more. Please see rubyonrails.org/community and ruby-lang.org/en/community for other Rails- und Ruby-related community platforms.
Peter E. (Guest)
on 2005-12-14 20:19
(Received via mailing list)
that why I love ruby (and functional languages in general)

def fibonacci(n)
  a, b = 1, 1
  n.times do
    a, b = b, a + b
  end
  a
end

elegance beats ignorance (ruby vs. java)
Jeffrey S. (Guest)
on 2005-12-14 21:10
(Received via mailing list)
Peter E. wrote:
> elegance beats ignorance (ruby vs. java)
What about that snippet demonstrates Ruby as a "functional language?"
Do you mean functional in the Haskell sense, or are you trying to say
something different?  Why have you chosen Java as the empitome of
ignorance?

Am I just feeding a troll?
Christian N. (Guest)
on 2005-12-14 21:28
(Received via mailing list)
"Peter E." <removed_email_address@domain.invalid> writes:

> that why I love ruby (and functional languages in general)
>
> def fibonacci(n)
>   a, b = 1, 1
>   n.times do
>     a, b = b, a + b
>   end
>   a
> end

That's not functional...

How about really doing it functional?

def fib(n)
  (1..n-2).inject([1, 1]) { |(a, b), n| [b, a+b] }.last
end

:)
Jeff W. (Guest)
on 2005-12-14 21:58
(Received via mailing list)
Nice.

On 12/14/05, Christian N. <removed_email_address@domain.invalid> wrote:
> >   a
> :)
>
> > elegance beats ignorance (ruby vs. java)
> --
> Christian N.  <removed_email_address@domain.invalid>  http://chneukirchen.org
>
>


--
"Remember. Understand. Believe. Yield! -> http://ruby-lang.org"

Jeff W.
Edward F. (Guest)
on 2005-12-14 22:01
(Received via mailing list)
On Thu, Dec 15, 2005 at 04:27:08AM +0900, Christian N. wrote:
> def fib(n)
>   (1..n-2).inject([1, 1]) { |(a, b), n| [b, a+b] }.last
> end

If we're talking about elegance, I prefer this one.  It reads just
like the definition of the sequence:

def fib(n)
    n > 1 ? fib(n-1) + fib(n-2) : n
end

You can even make it run efficiently by memoizing it.  :-)

-Ed
ako... (Guest)
on 2005-12-14 22:13
(Received via mailing list)
www.haskell.org
Christian N. (Guest)
on 2005-12-14 22:28
(Received via mailing list)
Edward F. <removed_email_address@domain.invalid> writes:

> end
Yes.  But Ruby is not tail-recursive (neither is your method), and
this solution wont work for bigger values.

> You can even make it run efficiently by memoizing it.  :-)

If it was about efficiency, I'd calculate them with the golden mean...
ako... (Guest)
on 2005-12-14 22:55
(Received via mailing list)
complexity, both time and space, is bad though.
Eric J. (Guest)
on 2005-12-15 01:08
(Received via mailing list)
"ako..." <removed_email_address@domain.invalid> writes:

> www.haskell.org

Yesssss. If only I/O operations were easier to manage...
Andrew B.er (Guest)
on 2005-12-15 08:43
(Received via mailing list)
def calc_iterative(n)
	a = [0,1,0]
	for i in 2..n
		a[k] = a[k-1] + a[k-2]
	end
	return a[n%3]
end

I like this one, since it uses array wrapping.  So many ways to write
it that are all *slightly*  different... But this was to show someone,
so :)
Matias S. (Guest)
on 2005-12-15 14:14
(Received via mailing list)
Jeff W.
escribió:>>>  a, b = 1, 1
>>def fib(n)
>>
>>
>
>
>
> --
> "Remember. Understand. Believe. Yield! -> http://ruby-lang.org"
>
> Jeff W.
>


You're all crazy.... :-)

(in the good sense... ;-) )
Robert K. (Guest)
on 2005-12-15 15:00
(Received via mailing list)
Matias S. wrote:
>>>>  a, b = 1, 1
>>> def fib(n)
>>> http://chneukirchen.org
>
>
> You're all crazy.... :-)
>
> (in the good sense... ;-) )

I didn't know there was a bad sense about it... ;-)

    robert
Stephen K. (Guest)
on 2005-12-15 15:54
(Received via mailing list)
In message <removed_email_address@domain.invalid>, Christian N.
<removed_email_address@domain.invalid> writes
>def fib(n)
>  (1..n-2).inject([1, 1]) { |(a, b), n| [b, a+b] }.last
>end

Thats about as readable as APL. Maintenance nightmare.

Stephen
jwesley (Guest)
on 2005-12-15 17:18
(Received via mailing list)
If Ruby properly handled tail-recursion, then the "accumulator passing"
style work for any number:

def fib n
  fib_helper( n, 1, 1)
end

def fib_helper n, next_val, val
  n < 1 ? val : fib_helper( n-1, next_val + val, next_val)
end

the above code (in accumulator-passing style) only works through about
n=1300 for me.

Justin
Christian N. (Guest)
on 2005-12-15 17:54
(Received via mailing list)
Stephen K. <removed_email_address@domain.invalid> writes:

> In message <removed_email_address@domain.invalid>, Christian N.
> <removed_email_address@domain.invalid> writes
>>def fib(n)
>>  (1..n-2).inject([1, 1]) { |(a, b), n| [b, a+b] }.last
>>end
>
> Thats about as readable as APL. Maintenance nightmare.

I disagree.  APL isn't about readability to outsiders (and this is IMO
not a thing every language needs to strive for, sometimes there are
things more important).  Take this piece of J:

  f =: 1:`($:@<:&<:+$:@<:)@.(1:<])

(taken from http://cubbi.org/serious/fibonacci/j.html)
Or, in K:

  fibonacci:{x(|+\)\1 1}

(taken from
http://www.kuro5hin.org/?op=displaystory;sid=2002/...)

Or, again in K:

  fx:{x{x,+/-2#x}/0 1}

(taken from http://www.kx.com/listbox/k/msg05165.html)

These all are far more unreadable to me, even though I know the basics
of APL...

Besides, what is there to maintain about fibonacci?
Peter E. (Guest)
on 2005-12-15 18:12
(Received via mailing list)
this is fibonacci written in Random++

f: @!$,.1,1^%#(*

very elegant and short :-)
Matt O'Connor (Guest)
on 2005-12-16 03:59
(Received via mailing list)
jwesley wrote:
>
> the above code (in accumulator-passing style) only works through about
> n=1300 for me.

Though a more "functional approach" is to hide the helper function:

def fib n
   def fib_helper n, next_val, val
     n < 1 ? val : fib_helper( n-1, next_val + val, next_val)
   end
   fib_helper( n, 1, 1)
end


Matt
baalbek (Guest)
on 2005-12-16 04:11
(Received via mailing list)
That's not functional...

How about: 107 * 1234 = 123 038

Now, that's functional!
Wayne V. (Guest)
on 2005-12-16 04:44
(Received via mailing list)
Hi Matt,

On 12/15/05, Matt O'Connor <removed_email_address@domain.invalid> wrote:
> Though a more "functional approach" is to hide the helper function:

I don't think this actually hides the helper function:

def fib n
  def fib_helper n, next_val, val
    n < 1 ? val : fib_helper( n-1, next_val + val, next_val)
  end
  fib_helper( n, 1, 1)
end

p fib(10)                      => 89
p fib_helper(10,1,1)      => 89

Wayne

---
Wayne V.
No Bugs Software
"Ruby and C++ Agile Contract Programming in Silicon Valley"
ako... (Guest)
on 2005-12-16 04:53
(Received via mailing list)
this one is in haskell:

fibonacci n = round((phi ** (x + 1) - (1 - phi) ** (x + 1)) / (sqrt 5))
  where phi = (1 + sqrt 5) / 2
        x = (fromInteger n)::Float
Eero S. (Guest)
on 2005-12-16 05:27
(Received via mailing list)
On 2005.12.16 11:51, "ako..." <removed_email_address@domain.invalid> wrote:
> this one is in haskell:
>
> fibonacci n = round((phi ** (x + 1) - (1 - phi) ** (x + 1)) / (sqrt 5))
>   where phi = (1 + sqrt 5) / 2
>         x = (fromInteger n)::Float


fibs :: [Int]
fibs = 0 : 1 : [ a + b | (a, b) <- zip fibs (tail fibs)]


E
Jeffrey S. (Guest)
on 2005-12-17 05:59
(Received via mailing list)
Matt O'Connor wrote:
>>   n < 1 ? val : fib_helper( n-1, next_val + val, next_val)
>     n < 1 ? val : fib_helper( n-1, next_val + val, next_val)
>   end
>   fib_helper( n, 1, 1)
> end

An alternative implementation might even use only one subroutine.

def fib n, p1 =1, p2 =1
	n < 1 ? p2 : fib( n - 1, p1 + p2, p1 )
end
Logan C. (Guest)
on 2005-12-19 08:33
(Received via mailing list)
On Dec 15, 2005, at 8:46 PM, Matt O'Connor wrote:

>> the above code (in accumulator-passing style) only works through
> end
>
>
> Matt
>

Sadly, that doesn't really hide the helper function. fib_helper will
be at the same scope as fib, Ruby doesn't currently do nested
function definitions.
Matt Silberstein (Guest)
on 2005-12-19 20:48
(Received via mailing list)
On 15 Dec 2005 07:17:22 -0800, in comp.lang.ruby , "jwesley"
<removed_email_address@domain.invalid> in
<removed_email_address@domain.invalid>  wrote:

>
>the above code (in accumulator-passing style) only works through about
>n=1300 for me.

It is grossly inefficient to implement fib as recursive even if it
seems like clever code.

--
Matt Silberstein

Do something today about the Darfur Genocide

http://www.beawitness.org
http://www.darfurgenocide.org
http://www.savedarfur.org

"Darfur: A Genocide We can Stop"
Dirk M. (Guest)
on 2005-12-27 00:45
(Received via mailing list)
i'm sorry for reviving an old topic, but hows this:

def fib(n)
    list=[0,1]
    2.upto(n-1) do |s|
        list << (list[s-2]+list[s-1])
    end
    list
end

greetings, Dirk.
This topic is locked and can not be replied to.