First-n Fibonacci sequence elements

There is a well known question here that asks for a short (least characters) fibonacci sequence generator.

I would like to know if someone can generate the first N elements only, of the fibonacci sequence, in very short space. I am trying to do it in python, but I'm interested in any short answer, in any language. Function F(N) generates the first N elements of the sequence, either returns them as the return of the function or prints them.

Interestingly it seems that the code-golf answers start with 1 1 2, instead of 0 1 1 2. Is that a convention in code-golf or programming-in-general? (Wikipedia says the fibonacci sequence starts with zero.).

Python Sample (First 5 Elements):

def f(i,j,n):
    if n>0:
        print i;
        f(j,i+j,n-1)
f(1,1,5)

Warren P

Posted 2012-01-17T20:41:32.723

Reputation: 229

1I realize this is quite an old challenge at this point, but note that you've accepted an answer which is not the shortest. Since this is a code golf competition, the shortest answer should be the one that's marked accepted. – Alex A. – 2016-02-12T00:21:08.290

1I think this is too similar to the linked question. Most solutions there can easily be modified to handle the first-n case. – hammar – 2012-01-17T20:52:11.530

In the case of Python, the interesting thing is that I need four lines of code, and two levels of indentation in my sample. I suspect there is a one liner in python, but I can't find it. – Warren P – 2012-01-17T20:56:26.500

I believe that the questions of "How does it start?" has a lot of history behind it, but I was usually taught starting with 1, 1. Does the Wikipedia give an authoritative source for 0, 1? – dmckee --- ex-moderator kitten – 2012-01-17T21:02:10.237

I remember it being introduced as 1, 1, .. in grade 7 when I was told about it. – Warren P – 2012-01-17T21:04:46.533

3Everywhere I've seen, the base cases are defined as F_0 = 0, F_1 = 1 or equivalently F_1 = 1, F_2 = 1. The difference is whether you want to start the sequence at index 0 (more common in programming) or 1 (more common in math). – hammar – 2012-01-17T21:19:49.537

1And defining F_0 = 0, F_1 = 1 has a definite benefit in simplicity with the matrix representation [[1 1][1 0]]^n = [[F_{n+1} F_n][F_n F_{n-1}]]. – Peter Taylor – 2012-01-17T23:36:53.603

1@Peter: Now that a good reason to prefer one to the other (I'd long preferred 0, 1 on esthetic grounds, but don't believe those to be pressing in and of themselves). – dmckee --- ex-moderator kitten – 2012-01-18T03:33:05.763

Answers

C

Didn't bother counting, but here's a fun example:

f(n){return n<4?1:f(--n)+f(--n);}
main(a,b){for(scanf("%d",&b);a++<=b;printf("%d ",f(a)));}

Proof it works.

I'm quite proud of this: I got bored, so I rearranged my code (with a few small additions) to make it where each line represents a value in the Fibonacci sequence.

                         #                                // 1
                         f                                // 1
                         //                               // 2
                        (n)                               // 3
                       {/**/                              // 5
                      return n                            // 8
                    <2 ? 1:f(--n)                         // 13
                +f(--n); } main(a, b)                     // 21
          {a = 0, b = 0;scanf("%d",&b); for(              // 34
;a < b; a+=1) { int res = f(a); printf("%d ", res); } }   // 55

Proof it works.

Mr. Llama

Posted 2012-01-17T20:41:32.723

Reputation: 2 387

Love it! This is a great example of where the undefined behavior of the ordering of the two instances of --n in the same expression is irrelevant. Brilliant! – Todd Lehman – 2019-09-09T21:15:29.330

By the way, I think your 4 there should actually be a 3. As currently written with the <4, the sequence produced is 1, 1, 1, 2, 3, 5, 8... That's one too many 1's. – Todd Lehman – 2019-09-09T21:25:27.427

Additionally, if you want to handle the zeroth element of the sequence correctly, you could add 2 characters and change the code to return n<3?n>0:f(--n)+f(--n); – Todd Lehman – 2019-09-09T21:29:51.250

Nice. 90 chars (without newline). Save 2 bytes: a++<=b-> a++-b and return--n<3?1:f(n)+f(n-1). Plus you can avoid scanf if you require n to be in argc. – ugoren – 2012-01-18T08:35:39.453

Haskell (26)

Surprisingly, this is only one character longer than the J solution.

f=(`take`s)
s=0:scanl(+)1s

I shave off a few characters by:

Using take as a binary operator;
Using scanl instead of the verbose zipWith.

Lambda Fairy

Posted 2012-01-17T20:41:32.723

Reputation: 311

It literally took me about half an hour to understand what is going on here, and the s is so elegant, I don't know how anyone would think of a solution like that! What I did not know is that you can use s again while defining s. (I'm still a beginner=) – flawr – 2016-03-06T09:53:28.983

Here's a one-liner Python. It uses floating-point, so there may be some n for which it is no longer accurate.

F=lambda n:' '.join('%d'%(((1+5**.5)/2)**i/5**.5+.5)for i in range(n))

F(n) returns a string containing the first n Fibonacci numbers separated by spaces.

Keith Randall

Posted 2012-01-17T20:41:32.723

Reputation: 19 865

I was thinking of doing this, but thought it would be too long. I didn't think about using flooring. Very nice. – Kris Harper – 2012-01-18T00:04:34.013

Ah, Binet's formula. I also used it & it's accurate, at least till the 59th fibonacci number if you count 0 as the first. After that the numbers become too big & it starts using exponents. – elssar – 2012-01-18T07:38:50.403

70 chars, 1 line, to define function. + 4 +crlf to invoke. Pretty good! – Warren P – 2012-01-18T17:53:09.083

GolfScript, 16 characters

~0 1@{.2$+}*;;]`

Example output:

$ ruby golfscript.rb ~/Code/golf/fib.gs <<< "12"
[0 1 1 2 3 5 8 13 21 34 55 89]

hammar

Posted 2012-01-17T20:41:32.723

Reputation: 4 011

Perl, 50 characters

sub f{($a,$b,$c)=@_;$c--&&say($a)&&f($b,$a+$b,$c)}

Toto

Posted 2012-01-17T20:41:32.723

Reputation: 909

Scala 71:

def f(c:Int,a:Int=0,b:Int=1):Unit={println(a);if(c>0)f(c-1,b,a+b)};f(9)

prints

user unknown

Posted 2012-01-17T20:41:32.723

Reputation: 4 210

Cool. I haven't even played with Scala yet. I will try it tonight at home. – Warren P – 2012-01-18T17:54:14.400

Perl, 29 28 bytes

perl -E'say$b+=$;=$b-$;for-pop..--$;' 8
1
1
2
3
5
8
13
21

Explanation

This is based on the classic $b += $a = $b-$a recurrence which works as follows:

At the start of each loop $a contains F(n-2) and $b contains F(n)
After $a = $b-$a $a contains F(n-1)
After $b += $a $b contains F(n+1)

The problem here is the initialization. The classical way is $b += $a = $b-$a || 1 but then the sequence goes 1 2 3 5 ...

By extending the fibonacci sequence to the left:

... 5 -3 2 -1 1 0 1 1 2 3 5 ...

you see that the proper starting point is $a = -1 and $b = 0. Initializing $a can be combined with setting up the loop

Finally replace $a by $; to get rid of the space before the for

Ton Hospel

Posted 2012-01-17T20:41:32.723

Reputation: 14 114

I can give you a two line Python solution. This will return them as a list.

f = lambda n: 1 if n < 2 else f(n-1) + f(n-2)
g = lambda m: map(f, range(0,m))

print g(5)

You could have it print them out by adding another map to make them strings and then adding a join, but that just seems unnecessary to me.

Unfortunately I don't know how to put a recursive lambda into map, so I'm stuck at two lines.

Kris Harper

Posted 2012-01-17T20:41:32.723

Reputation: 181

What's it return for g(100)? ;) – Mr. Llama – 2012-01-17T22:13:38.010

@GigaWatt Heh, OP never said it had to be reasonable. Is the asymptotic running time something like O(n(1.62)^n)? – Kris Harper – 2012-01-18T00:11:39.633

Here's one way you can (kind of) do this. Note that f(n) with n<=0 returns integers, and n>0 returns lists, so.. maybe it isn't ideal: f = lambda n: map(f, (-x for x in range(0, n))) if n > 0 else -n if n > -2 else f(n+1) + f(n+2) – Dillon Cower – 2012-01-19T02:48:41.490

By the way, you missed the first 0 in your answer. Changing f to return n if n < 2 is one workaround. :) – Dillon Cower – 2012-01-19T02:51:13.640

@DC I like your solution. Pretty creative. Yeah, I made mine start with 1, 1 because that's how I always learned it. I figured changing it was easy enough. – Kris Harper – 2012-01-19T12:07:32.193

Python (78 chars)

I used Binet's formula to calculate the fibonacci numbers -

[(1+sqrt(5))^n-(1-sqrt(5)^n]/[(2^n)sqrt(5)]

It's not as small some of the other answers here, but boy it's fast

n=input()
i=1
x=5**0.5
while i<=n:
    print ((1+x)**i-(1-x)**i)/((2**i)*x)
    i+=1

elssar

Posted 2012-01-17T20:41:32.723

Reputation: 579

1Python (12 chars): print"11235" :) – Joel Cornett – 2012-05-13T16:53:54.493

You can shave 2 chars off by getting rid of the parentheses around 2**i. ** have higher precedence than * – Joel Cornett – 2012-05-13T17:05:39.597

The second term in binet's formula starts small and only gets smaller. You can leave it out completely and just round the result of the first term to the nearest integer instead (or add 0.5 and round down) – Ton Hospel – 2016-03-06T19:18:22.263

Scheme

This is optimized using tail-recursion:

(define (fib n)
  (let fib ([n n] [a 0] [b 1])
    (if (zero? n) (list a)
        (cons a (fib (- n 1) b (+ a b))))))

Samuel Duclos

Posted 2012-01-17T20:41:32.723

Reputation: 136

Haskell

fib n = take n f
f = 0:1:zipWith (+) f (tail f)

Proof that it works.

lbolla

Posted 2012-01-17T20:41:32.723

Reputation: 121

You can make it one function using where – Hauleth – 2012-05-02T08:30:35.933

J, 25 characters

I realise that J solutions are probably not what you're after, but here's one anyway. :-)

0 1(],+/&(_2&{.))@[&0~2-~

Usage:

    0 1(],+/&(_2&{.))@[&0~2-~ 6
0 1 1 2 3 5
    0 1(],+/&(_2&{.))@[&0~2-~ 10
0 1 1 2 3 5 8 13 21 34

How it works:

Starting from the right (because J programs are read from right to left),

2-~ 6 The ~ operator reverses the argument to the verb so this is the same as 6-2

Ignoring the section in brackets for now, 0 1(...)@[&0~ xtakes the verb in the brackets and executes it x times using the list 0 1 as its input - ~ again reverses the arguments here, giving x (...)@[&0 ] 0 1, meaning I can keep the input at the end of the function.

Within the brackets is a fork ],+/&(_2&{.) which is made up of three verbs - ], , and +/&(_2&{.).

A fork takes three verbs a b c and uses them like this: (x a y) b (x c y) where x and y are the arguments to the fork. The , is the centre verb in this fork and joins the results of x ] y and x +/&(_2&{.) y together.

] returns the left argument unaltered so x ] y evaluates to x.

+/&(_2&{.) takes the last two items from the given list (_2&{.) - in this case 0 1 - and then adds them together +/ (the &s just act as glue).

Once the verb has operated once the result is fed back in for the next run, generating the sequence.

Gareth

Posted 2012-01-17T20:41:32.723

Reputation: 11 678

Python(55)

a,b=0,1

for i in range(int(input())):a,b=b,a+b;print(b)

Donald Hobson

Posted 2012-01-17T20:41:32.723

Reputation: 21

TI-Basic, 43 characters

:1→Y:0→X
:For(N,1,N
:Disp X
:Y→Z
:X+Y→Y
:Z→X
:End

This code can be directly inserted into the main program, or made into a separate program that is referenced by the first.

PhiNotPi

Posted 2012-01-17T20:41:32.723

Reputation: 26 739

This is the first TI-BASIC solution I've ever seen here that wasn't by me :) +1 – Timtech – 2014-01-10T00:06:21.933

Also, note for other people that newlines are not counted here because they can be removed. – Timtech – 2014-01-10T00:13:30.727

I just got a TI-92 big-giant-qwerty-keyboard calculator. Thanks for this one. – Warren P – 2014-09-02T13:49:10.670

APL (33)

{⍎'⎕','←0,1',⍨'←A,+/¯2↑A'⍴⍨9×⍵-2}

Usage:

   {⍎'⎕','←0,1',⍨'←A,+/¯2↑A'⍴⍨9×⍵-2}7
0 1 1 2 3 5 8

marinus

Posted 2012-01-17T20:41:32.723

Reputation: 30 224

Is the box character ⎕ part of APL or a missing-glyph? – Warren P – 2014-09-02T13:48:36.810

@WarrenP: If you mean the 4th character from the left, that's called a 'quad' and it's supposed to look like that. There should be only one box. – marinus – 2014-09-03T07:23:02.963

Python 2, 38 Bytes

An improvement on a previously posted solution:

a=b=1
exec'print a;a,b=b,a+b;'*input()

This uses exec and string multiplication to avoid loops.

Python 3, 46 Bytes

Not quite as efficient in Python 3:

a=b=1
exec('print(a);a,b=b,a+b;'*int(input()))

Russell Schwartz

Posted 2012-01-17T20:41:32.723

Reputation: 11

By switching to Python 2 you can save 9 bytes: Try It Online! You probably can add the Python 2 version to your answer.

– Stephen – 2020-02-06T00:23:40.683

@Stephen Good point! Updated. – Russell Schwartz – 2020-02-07T01:17:03.600

Powershell - 35 characters

Powershell accepts pipeline input, so I'm of the belief that the n | in n | <mycode> shouldn't be against my count, but instead is just a part of initiating a "function" in the language.

The first solution assumes we start at 0:

%{for($2=1;$_--){($2=($1+=$2)-$2)}}

The second solution assumes we can start at 1:

%{for($2=1;$_--){($1=($2+=$1)-$1)}}

Example invocation: 5 | %{for($2=1;$_--){($1=($2+=$1)-$1)}}

Yields:

Interestingly, attempts to avoid the overhead of the for() loop resulted in the same character count: %{$2=1;iex('($1=($2+=$1)-$1);'*$_)}.

SpellingD

Posted 2012-01-17T20:41:32.723

Reputation: 121

FALSE, 28 bytes

0 1- 1 10[$][@@$@+$." "@1-]#

user3725

Posted 2012-01-17T20:41:32.723

Reputation:

You can generate -1 using 1_ rather than 0 1 - – 12Me21 – 2018-01-31T14:12:32.117

Python, 43 chars

Here are three fundamentally different one-liners that don't use Binet's formula.

f=lambda n:reduce(lambda(r,a,b),c:(r+[b],a+b,a),'.'*n,([],1,0))[0]
f=lambda n:map(lambda x:x.append(x[-1]+x[-2])or x,[[0,1]]*n)[0]
def f(n):a=0;b=1;exec'print a;a,b=b,a+b;'*n

I've never abused reduce so badly.

boothby

Posted 2012-01-17T20:41:32.723

Reputation: 9 038

1+1 for reduce abuse – Warren P – 2012-06-01T21:34:54.923

dc, 32 characters:

This will actually always show the two first 1's, so the function only work as expected for N >= 2.

?2-sn1df[dsa+plarln1-dsn0<q]dsqx

C, 75 characters:

Not as cool as the accepted answer, but shorter and way faster:

main(n,t,j,i){j=0,i=scanf("%d",&n);while(n--)t=i,i=j,printf("%d\n",j+=t);}

Extra:

CL, 64 characters:

One of my most used bookmarks this semester has an interesting example which is shorter than ~~many~~ some of the other ones here, and it's just a straight-forward invocation of the loop macro -- basically just one statement! Stripped it for all the whitespace I could:

(loop repeat n for x = 0 then y and y = 1 then(+ x y)collect y)

Quite short, and nice and readable! To read input, n (including surrounding whitespaces) can be replaced with (read), adding 3 characters.

daniero

Posted 2012-01-17T20:41:32.723

Reputation: 17 193

Does... does main take four arguments? – cat – 2016-03-06T20:20:31.243

1It takes as many as you give it. In this case it's just (ab)used to define a few variables that are used later :) – daniero – 2016-03-07T12:31:30.383

FALSE, 20 characters

^1@[1-$][@2ø+$.\9,]#

Input should be on the stack before running this.

12Me21

Posted 2012-01-17T20:41:32.723

Reputation: 6 110

Pyt, 3 bytes

ř⁻Ḟ

Try it online!

ř creates an array [1, 2, 3, ..., x]
⁻ decrements every item once (as Ḟ is 0 indexed)
Ḟ for every item in x converts it to it's fibonacci equivalent

FantaC

Posted 2012-01-17T20:41:32.723

Reputation: 1 425

x86 machine code - 379 bytes

The version with ELF headers scoring 484 bytes:

00000000: 7f45 4c46 0101 0100 0000 0000 0000 0000  .ELF............
00000010: 0200 0300 0100 0000 c080 0408 3400 0000  ............4...
00000020: 0000 0000 0000 0000 3400 2000 0200 2800  ........4. ...(.
00000030: 0000 0000 0100 0000 0000 0000 0080 0408  ................
00000040: 0000 0000 e401 0000 0010 0000 0500 0000  ................
00000050: 0010 0000 0100 0000 0000 0000 0090 0408  ................
00000060: 0000 0000 0000 0000 0000 1000 0600 0000  ................
00000070: 0010 0000 0000 0000 0000 0000 0000 0000  ................
00000080: 51b9 0090 0408 8801 31c0 ba01 0000 00eb  Q.......1.......
00000090: 0351 89c1 31c0 89c3 43b0 04cd 8031 c099  .Q..1...C....1..
000000a0: 4259 c300 0000 0000 0000 0000 0000 0000  BY..............
000000b0: 0000 0000 0000 0000 0000 0000 0000 0000  ................
000000c0: 31c0 9942 b903 9004 08c6 4101 0ac6 4102  1..B......A...A.
000000d0: 01c6 4103 013a 7103 0f84 ff00 0000 3a71  ..A..:q.......:q
000000e0: 0374 2680 4103 050f b641 036b c008 0041  .t&.A....A.k...A
000000f0: 048a 4104 e887 ffff ff80 6904 30c6 4103  ..A.......i.0.A.
00000100: 0183 e903 3a71 0375 da8a 4104 e86f ffff  ....:q.u..A..o..
00000110: ff3a 7106 0f84 ba00 0000 0fb6 4105 8841  .:q.........A..A
00000120: 060f b641 0788 4105 0fb6 4107 0041 06c6  ...A..A...A..A..
00000130: 4107 003a 7106 0f84 8800 0000 c641 0701  A..:q........A..
00000140: fe49 063a 7106 0f84 7800 0000 c641 0702  .I.:q...x....A..
00000150: fe49 063a 7106 0f84 6800 0000 c641 0703  .I.:q...h....A..
00000160: fe49 063a 7106 0f84 5800 0000 c641 0704  .I.:q...X....A..
00000170: fe49 063a 7106 744c c641 0705 fe49 063a  .I.:q.tL.A...I.:
00000180: 7106 7440 c641 0706 fe49 063a 7106 7434  q.t@.A...I.:q.t4
00000190: c641 0707 fe49 063a 7106 7428 c641 0708  .A...I.:q.t(.A..
000001a0: fe49 063a 7106 741c c641 0709 fe49 063a  .I.:q.t..A...I.:
000001b0: 7106 7410 fe41 08fe 4109 fe49 060f b641  q.t..A..A..I...A
000001c0: 0688 4107 c641 0601 83c1 033a 7106 0f85  ..A..A.....:q...
000001d0: 46ff ffff 3a71 030f 8501 ffff ffb3 0031  F...:q.........1
000001e0: c040 cd80                                .@..

Headerless version (that is the one to be graded):

00000000: 67c6 4101 0a67 c641 0201 67c6 4103 0167  g.A..g.A..g.A..g
00000010: 3a71 030f 842a 0167 3a71 0374 2e67 8041  :q...*.g:q.t.g.A
00000020: 0305 6667 0fb6 4103 666b c008 6700 4104  ..fg..A.fk..g.A.
00000030: 678a 4104 e80d 0167 8069 0430 67c6 4103  g.A....g.i.0g.A.
00000040: 0166 83e9 0367 3a71 0375 d267 8a41 04e8  .f...g:q.u.g.A..
00000050: f200 673a 7106 0f84 df00 6667 0fb6 4105  ..g:q.....fg..A.
00000060: 6788 4106 6667 0fb6 4107 6788 4105 6667  g.A.fg..A.g.A.fg
00000070: 0fb6 4107 6700 4106 67c6 4107 0067 3a71  ..A.g.A.g.A..g:q
00000080: 060f 84a3 0067 c641 0701 67fe 4906 673a  .....g.A..g.I.g:
00000090: 7106 0f84 9200 67c6 4107 0267 fe49 0667  q.....g.A..g.I.g
000000a0: 3a71 060f 8481 0067 c641 0703 67fe 4906  :q.....g.A..g.I.
000000b0: 673a 7106 0f84 7000 67c6 4107 0467 fe49  g:q...p.g.A..g.I
000000c0: 0667 3a71 0674 6167 c641 0705 67fe 4906  .g:q.tag.A..g.I.
000000d0: 673a 7106 7452 67c6 4107 0667 fe49 0667  g:q.tRg.A..g.I.g
000000e0: 3a71 0674 4367 c641 0707 67fe 4906 673a  :q.tCg.A..g.I.g:
000000f0: 7106 7434 67c6 4107 0867 fe49 0667 3a71  q.t4g.A..g.I.g:q
00000100: 0674 2567 c641 0709 67fe 4906 673a 7106  .t%g.A..g.I.g:q.
00000110: 7416 67fe 4108 67fe 4109 67fe 4906 6667  t.g.A.g.A.g.I.fg
00000120: 0fb6 4106 6788 4107 67c6 4106 0166 83c1  ..A.g.A.g.A..f..
00000130: 0367 3a71 060f 8521 ff67 3a71 030f 85d6  .g:q...!.g:q....
00000140: fe00 0000 6651 66b9 7801 0000 6788 0166  ....fQf.x...g..f
00000150: 31c0 66ba 0100 0000 eb05 6651 6689 c166  1.f.......fQf..f
00000160: 31c0 6689 c366 43b0 04cd 8066 31c0 6699  1.f..fC....f1.f.
00000170: 6642 6659 c300 0000 0000 00              fBfY.......

Calculates (possibly) \$ \infty \$ fibonacci numbers.

Krzysztof Szewczyk

Posted 2012-01-17T20:41:32.723

Reputation: 3 819

Japt, 4 bytes

Starts from 0.

o!gM

Try it

Shaggy

Posted 2012-01-17T20:41:32.723

Reputation: 24 623

C99, 58 characters

The following function fills an array of integers with the first n values from the Fibonacci sequence starting with 0.

void f(int*a,int n){for(int p=0,q=1;n--;q+=*a++)*a=p,p=q;}

Test harness, taking n as a command line argument:

#include <stdlib.h>
#include <stdio.h>
int main(int argc, char *argv[]) {
     int n = (argc > 1) ? atoi(argv[1]) : 1;
     int a[n];
     f(a, n);
     for (int i = 0; i < n; ++i)
          printf("%d\n", a[i]);
}

han

Posted 2012-01-17T20:41:32.723

Reputation: 1 226

Lua, 85 bytes

I am learning Lua so I would like to add this language to the pool.

function f(x)
    return (x<3) and 1 or f(x-1)+f(x-2)
end
for i=1,io.read() do
    print(f(i))
end

and the whole thing took 85 characters, with the parameter as a command line argument. Another good point is that is easy to read.

user3781

Posted 2012-01-17T20:41:32.723

Reputation:

Q 24

f:{{x,sum -2#x}/[x;0 1]}

First n fibonacci numbers

sinedcm

Posted 2012-01-17T20:41:32.723

Reputation: 410

CoffeeScript, 48

f=(n,i=1,j=1)->(console.log i;f n-1,j,i+j)if n>0

65 in js:

function f(n,i,j){if(n>0)console.log(i),f(n-1,(j=j||1),(i||1)+j)}

Ricardo Tomasi

Posted 2012-01-17T20:41:32.723

Reputation: 131

PHP, 87

function f($n,$a=array(0,1)){echo' '.$a[0];$n>0?f(--$n,array($a[1],array_sum($a))):'';}

Uses array_sum and recursive function to generate series.

Eg:

 $ php5 fibo.php 9
 0 1 1 2 3 5 8 13 21 34

karthik

Posted 2012-01-17T20:41:32.723

Reputation: 111

F#, 123

let f n = Seq.unfold(fun (i,j)->Some(i,(j,i+j)))(0,1)|>Seq.take n
f 5|>Seq.iter(fun x->printfn "%i" x)

Smetad Anarkist

Posted 2012-01-17T20:41:32.723

Reputation: 363

Scala, 65 characters

(Seq(1,0)/:(3 to 9)){(s,_)=>s.take(2).sum+:s}.sorted map println

This prints, for example, the first 9 Fibonacci numbers. For a more useable version taking the sequence length from console input, 70 characters are required:

(Seq(1,0)/:(3 to readInt)){(s,_)=>s.take(2).sum+:s}.sorted map println

Beware the use of a Range limits this to Int values.

Don Mackenzie

Posted 2012-01-17T20:41:32.723

Reputation: 131

Asked: 2012-01-17T20:41:32.723

Viewed: 4 141 times

Active: 2020-02-07T01:14:40.233