# Ruby beats them all

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)

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?

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

Nice.

On 12/14/05, Christian N. removed_email_address@domain.invalid wrote:

a

elegance beats ignorance (ruby vs. java)

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

Jeff W.

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

complexity, both time and space, is bad though.

Yesssss. If only I/O operations were easier to manage…

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…

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

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… )

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

Stephen

Matias S. wrote:

a, b = 1, 1
def fib(n)
http://chneukirchen.org

You’re all crazy…

(in the good sense… )

``robert``

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

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}

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?

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

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

That’s not functional…

How about: 107 * 1234 = 123 038

Now, that’s functional!

this is fibonacci written in Random++

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

very elegant and short

fibonacci n = round((phi ** (x + 1) - (1 - phi) ** (x + 1)) / (sqrt 5))
where phi = (1 + sqrt 5) / 2
x = (fromInteger n)::Float

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”