มีคำถามที่รู้จักกันดีที่นี่ซึ่งขอเครื่องกำเนิดลำดับลำดับฟีโบนักชีสั้น ๆ

ฉันต้องการที่จะรู้ว่าใครบางคนสามารถสร้างองค์ประกอบ N แรกเท่านั้นจากลำดับฟีโบนักชีในพื้นที่ที่สั้นมาก ฉันพยายามทำมันด้วยไพ ธ อน แต่ฉันสนใจคำตอบสั้น ๆ ในภาษาใด ๆ ฟังก์ชั่น F (N) สร้างองค์ประกอบ N แรกของลำดับทั้งส่งคืนพวกเขาเป็นการกลับมาของฟังก์ชั่นหรือพิมพ์พวกเขา

ที่น่าสนใจมันก็ดูเหมือนว่าคำตอบรหัสกอล์ฟเริ่มต้นด้วยแทน1 1 2 0 1 1 2นั่นคือการประชุมในการเขียนโปรแกรมกอล์ฟหรือการเขียนโปรแกรมทั่วไป? (วิกิพีเดียบอกว่าลำดับฟีโบนักชีเริ่มต้นด้วยศูนย์)

ตัวอย่าง Python (5 องค์ประกอบแรก):

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

ค

ไม่ได้ใส่ใจนับ แต่นี่เป็นตัวอย่างที่สนุก:

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

พิสูจน์การทำงาน

ฉันค่อนข้างภูมิใจในสิ่งนี้: ฉันเบื่อดังนั้นฉันจึงจัดเรียงโค้ดของฉันใหม่ (โดยมีการเพิ่มเติมเล็กน้อย) เพื่อให้บรรทัดแต่ละบรรทัดแสดงค่าในลำดับฟีโบนักชี

                         #                                // 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

พิสูจน์การทำงาน

Haskell (26)

น่าแปลกที่นี่มีอักขระเพียงตัวเดียวที่ยาวกว่าโซลูชัน J

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

ฉันโกนตัวละครไม่กี่ตัวโดย:

1. ใช้takeเป็นตัวดำเนินการไบนารี
2. ใช้scanlแทน zipWithverbose

นี่คือ Python แบบหนึ่งซับ มันใช้ floating-point ดังนั้นอาจมีบางอย่างnที่ไม่ถูกต้องอีกต่อไป

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

F(n)ส่งคืนสตริงที่มีnหมายเลข Fibonacci แรกคั่นด้วยช่องว่าง

GolfScript 16 ตัวอักษร

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

ตัวอย่างผลลัพธ์:

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

Perl, 50 ตัวอักษร

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

สกาลา 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)

พิมพ์

0
1
1
2
3
5
8
13
21
34

Perl, 29 28 ไบต์

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

คำอธิบาย

นี่คือพื้นฐานของการ$b += $a = $b-$aเกิดซ้ำแบบคลาสสิกซึ่งทำงานดังนี้:

• ที่จุดเริ่มต้นของแต่ละวง$aมีF(n-2)และ$bมีF(n)
• หลังจากนั้น$a = $b-$a $aมีF(n-1)
• หลังจากนั้น$b += $a $bมีF(n+1)

ปัญหาที่นี่คือการเริ่มต้น วิธีคลาสสิคคือ$b += $a = $b-$a || 1แต่แล้วลำดับไป1 2 3 5 ...

โดยการขยายลำดับฟีโบนักชีไปทางซ้าย:

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

คุณจะเห็นว่าเป็นจุดเริ่มต้นที่เหมาะสมคือและ$a = -1 $b = 0การเริ่มต้น $ a สามารถรวมกับการตั้งค่าลูป

ในที่สุดแทนที่$aด้วย$;เพื่อกำจัดพื้นที่ก่อนfor

ฉันให้โซลูชัน Python สองบรรทัดแก่คุณ นี่จะคืนค่าเป็นรายการ

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)

คุณสามารถให้มันพิมพ์ออกมาได้โดยการเพิ่มแผนที่อื่นเพื่อทำให้เป็นสตริงและจากนั้นเพิ่มการเข้าร่วม แต่นั่นก็ไม่จำเป็นสำหรับฉัน

น่าเสียดายที่ฉันไม่รู้ว่าจะเอาแลมบ์ดาแบบวนซ้ำได้mapฉันจึงติดอยู่ที่สองบรรทัด

Python (78 ตัวอักษร)

ฉันใช้สูตรของ Binetเพื่อคำนวณตัวเลขฟีโบนักชี -

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

มันไม่ใช่คำตอบอื่น ๆ ที่นี่เล็ก แต่เป็นคำตอบที่รวดเร็ว

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

โครงการ

นี่คือการเพิ่มประสิทธิภาพโดยใช้การเรียกซ้ำแบบหาง:

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

Haskell

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

พิสูจน์ว่ามันใช้งานได้

J, 25 ตัวอักษร

ฉันรู้ว่าการแก้ปัญหา J อาจไม่ใช่สิ่งที่คุณต้องการ แต่นี่คือวิธีแก้ปัญหา :-)

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

การใช้งาน:

    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

มันทำงานอย่างไร:

เริ่มจากด้านขวา (เนื่องจากโปรแกรม J อ่านจากขวาไปซ้าย)

2-~ 6~ประกอบการฝืนอาร์กิวเมนต์กริยาดังนั้นนี้เป็นเช่นเดียวกับ6-2

ละเว้นส่วนในวงเล็บสำหรับตอนนี้0 1(...)@[&0~ xใช้กริยาในวงเล็บและดำเนินการxครั้งโดยใช้รายการ0 1เป็นอินพุต - ~กลับอาร์กิวเมนต์ที่นี่อีกครั้งให้x (...)@[&0 ] 0 1ความหมายฉันสามารถเก็บข้อมูลที่ท้ายฟังก์ชั่น

ภายในวงเล็บคือส้อม],+/&(_2&{.)ซึ่งประกอบด้วยกริยาสามคำ - ], ,และ+/&(_2&{.)และ

ส้อมใช้กริยาสามตัวa b cและใช้พวกมันดังนี้: (x a y) b (x c y)ที่ไหนxและyเป็นอาร์กิวเมนต์ของ fork หรือไม่ ,เป็นคำกริยาในศูนย์ส้อมนี้และร่วมผลการx ] yและx +/&(_2&{.) yร่วมกัน

]ส่งกลับอาร์กิวเมนต์ซ้ายไม่เปลี่ยนแปลงดังนั้นประเมินx ] yx

+/&(_2&{.)ใช้สองรายการสุดท้ายจากรายการที่กำหนด(_2&{.)- ในกรณีนี้0 1- แล้วเพิ่มเข้าด้วยกัน+/( &เพียงทำหน้าที่เป็นกาว)

เมื่อกริยาดำเนินการแล้วผลลัพธ์จะถูกป้อนเข้าสู่การรันครั้งถัดไปสร้างลำดับ

TI-Basic, 43 ตัวอักษร

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

รหัสนี้สามารถแทรกลงในโปรแกรมหลักโดยตรงหรือสร้างเป็นโปรแกรมแยกต่างหากที่ถูกอ้างอิงโดยโปรแกรมแรก

APL (33)

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

การใช้งาน:

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

งูหลาม (55)

a,b=0,1

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

Powershell - 35 ตัวอักษร

Powershell ยอมรับการป้อนข้อมูลไปป์ไลน์ดังนั้นฉันจึงเชื่อn |ในตัวn | <mycode>ไม่ควรเทียบกับการนับของฉัน แต่แทนที่จะเป็นเพียงส่วนหนึ่งของการเริ่มต้น "ฟังก์ชั่น" ในภาษา

ทางออกแรกถือว่าเราเริ่มต้นที่ 0:

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

ทางออกที่สองถือว่าเราสามารถเริ่มต้นที่ 1:

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

ตัวอย่างการร้องขอ: 5 | %{for($2=1;$_--){($1=($2+=$1)-$1)}}

อัตราผลตอบแทน:

1
1
2
3
5

ที่น่าสนใจความพยายามที่จะหลีกเลี่ยงค่าใช้จ่ายของห่วงผลในการนับจำนวนตัวอักษรเดียวกันfor()%{$2=1;iex('($1=($2+=$1)-$1);'*$_)}

Python 43 ตัวอักษร

นี่คือหนึ่งในสามตอร์ปิโดที่แตกต่างกันโดยพื้นฐานซึ่งไม่ได้ใช้สูตรของ Binet

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

ฉันไม่เคยถูกทำร้ายreduceอย่างรุนแรง

dc, 32 ตัวอักษร:

สิ่งนี้จะแสดงสอง 1 แรกเสมอดังนั้นฟังก์ชันจะทำงานตามที่คาดไว้สำหรับ N> = 2เท่านั้น

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

C, 75 ตัวอักษร:

ไม่เท่ห์เหมือนคำตอบที่ยอมรับ แต่สั้นกว่าและเร็วกว่า:

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

CL, 64 ตัวอักษร:

หนึ่งในบุ๊คมาร์คที่ฉันใช้บ่อยที่สุดในภาคการศึกษานี้มีตัวอย่างที่น่าสนใจซึ่งสั้นกว่าอีกหลายๆ อันที่นี่และมันเป็นเพียงการขอร้องloopมาโครแบบตรงไปข้างหน้า ถอดมันสำหรับช่องว่างทั้งหมดที่ฉันสามารถทำได้:

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

ค่อนข้างสั้นและดีและอ่านได้! หากต้องการอ่านอินพุตn (รวมถึงช่องว่างโดยรอบ) สามารถแทนที่ด้วย(read)โดยเพิ่ม 3 ตัวอักษร

FALSE, 28 ไบต์

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

Python 2, 38 ไบต์

การปรับปรุงโซลูชันที่โพสต์ก่อนหน้านี้:

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

การใช้execและการคูณสตริงเพื่อหลีกเลี่ยงการวนซ้ำ

Python 3, 46 ไบต์

ไม่ค่อยมีประสิทธิภาพเท่าใน Python 3:

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

C99, 58 ตัวอักษร

ฟังก์ชันต่อไปนี้เติมอาร์เรย์ของจำนวนเต็มด้วยnค่าแรกจากลำดับฟีโบนักชีเริ่มต้นด้วย 0

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

ทดสอบการเทียมโดยใช้nเป็นอาร์กิวเมนต์บรรทัดคำสั่ง:

#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]);
}

CoffeeScript, 48

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

65 ใน js:

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

PHP, 87

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

ใช้array_sumและเรียกซ้ำฟังก์ชันเพื่อสร้างซีรีส์

เช่น:

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

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)

สกาลา 65 ตัวอักษร

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

ตัวอย่างนี้จะพิมพ์ตัวเลข 9 Fibonacci แรก สำหรับเวอร์ชันที่มีประโยชน์มากขึ้นโดยใช้ความยาวของลำดับจากอินพุตคอนโซลจำเป็นต้องใช้อักขระ 70 ตัว:

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

ระวังการใช้ Range จำกัด สิ่งนี้เป็นค่า Int

คำถามที่ 24

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

ตัวเลขแรกของฟีโบนักชี

Lua, 85 ไบต์

ฉันกำลังเรียนรู้ Lua ดังนั้นฉันต้องการเพิ่มภาษานี้ลงในสระว่ายน้ำ

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

และทั้งหมดนั้นมี 85 ตัวอักษรโดยพารามิเตอร์เป็นอาร์กิวเมนต์บรรทัดคำสั่ง อีกจุดที่ดีคืออ่านง่าย

FALSE 20 ตัวอักษร

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

อินพุตควรอยู่ในสแต็กก่อนที่จะรันสิ่งนี้

Pyt , 3 ไบต์

ř⁻Ḟ

ลองออนไลน์!

řสร้างอาร์เรย์ [1, 2, 3, ... , x]
⁻ decrements ทุกรายการหนึ่งครั้ง (เป็นḞคือ 0 ดัชนี)
Ḟสำหรับทุกรายการใน x จะแปลงเป็นฟีโบนักชีเทียบเท่า

รหัสเครื่อง x86 - 379 ไบต์

รุ่นที่มีส่วนหัวของ ELF ให้คะแนน 484 ไบต์:

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

รุ่นส่วนหัว (นั่นคือรุ่นที่จะให้คะแนน):

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

คำนวณ (อาจ) $\infty$ ตัวเลขฟีโบนักชี