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)

on 2005-12-14 20:19

on 2005-12-14 21:10

```
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?
```

on 2005-12-14 21:28

"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 :)

on 2005-12-14 21:58

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.

on 2005-12-14 22:01

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

on 2005-12-14 22:28

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...

on 2005-12-15 01:08

```
"ako..." <removed_email_address@domain.invalid> writes:
> www.haskell.org
Yesssss. If only I/O operations were easier to manage...
```

on 2005-12-15 08:43

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

on 2005-12-15 14:14

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... ;-) )

on 2005-12-15 15:00

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

on 2005-12-15 15:54

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

on 2005-12-15 17:18

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

on 2005-12-15 17:54

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?

on 2005-12-15 18:12

this is fibonacci written in Random++ f: @!$,.1,1^%#(* very elegant and short :-)

on 2005-12-16 03:59

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

on 2005-12-16 04:11

That's not functional... How about: 107 * 1234 = 123 038 Now, that's functional!

on 2005-12-16 04:44

```
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"
```

on 2005-12-16 04:53

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

on 2005-12-16 05:27

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

on 2005-12-17 05:59

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

on 2005-12-19 08:33

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.

on 2005-12-19 20:48

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"

on 2005-12-27 00:45

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.