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?
“Peter E.” [email protected] 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
Nice.
On 12/14/05, Christian N. [email protected] wrote:
a
elegance beats ignorance (ruby vs. java)
–
Christian N. [email protected] http://chneukirchen.org
–
“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.
Edward F. [email protected] 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…
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… 
)
In message [email protected], Christian N.
[email protected] 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
Matias S. wrote:
a, b = 1, 1
def fib(n)
http://chneukirchen.orgYou’re all crazy…
(in the good sense…
I didn’t know there was a bad sense about it…
robert
Stephen K. [email protected] writes:
In message [email protected], Christian N.
[email protected] writesdef fib(n)
(1…n-2).inject([1, 1]) { |(a, b), n| [b, a+b] }.last
endThats 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 cubbi.com: fibonacci numbers in J)
Or, in K:
fibonacci:{x(|+)\1 1}
(taken from
kuro5hin.org)
Or, again in K:
fx:{x{x,+/-2#x}/0 1}
(taken from 404-Error | KX)
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
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
Hi Matt,
On 12/15/05, Matt O’Connor [email protected] 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”