Ada pertanyaan terkenal di sini yang meminta generator urutan fibonacci pendek (paling tidak karakter).

Saya ingin tahu apakah seseorang dapat menghasilkan elemen N pertama saja, dari urutan fibonacci, dalam ruang yang sangat singkat. Saya mencoba melakukannya dengan python, tetapi saya tertarik dengan jawaban singkat, dalam bahasa apa pun. Fungsi F (N) menghasilkan elemen N pertama dari urutan, baik mengembalikannya sebagai pengembalian fungsi atau mencetaknya.

Menariknya tampaknya jawaban kode-golf dimulai dengan 1 1 2, alih-alih 0 1 1 2. Apakah itu konvensi dalam kode-golf atau pemrograman-secara umum? (Wikipedia mengatakan urutan fibonacci dimulai dengan nol.).

Contoh Python (5 Elemen Pertama):

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

C

Tidak repot menghitung, tapi ini contoh yang menyenangkan:

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

Buktinya berhasil.

Saya cukup bangga dengan ini: Saya bosan, jadi saya mengatur ulang kode saya (dengan beberapa tambahan kecil) untuk membuatnya di mana setiap baris mewakili nilai dalam urutan Fibonacci.

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

Buktinya berhasil.

Haskell (26)

Anehnya, ini hanya satu karakter lebih panjang dari solusi J.

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

Saya mencukur beberapa karakter dengan:

1. Menggunakan takesebagai operator biner;
2. Menggunakan scanlbukannya verbose zipWith.

Ini Python satu-baris. Ini menggunakan floating-point, jadi mungkin ada beberapa nyang tidak lagi akurat.

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

F(n)mengembalikan string yang berisi nangka Fibonacci pertama yang dipisahkan oleh spasi.

GolfScript, 16 karakter

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

Contoh output:

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

Perl, 50 karakter

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

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)

cetakan

0
1
1
2
3
5
8
13
21
34

Perl, 29 28 byte

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

Penjelasan

Ini didasarkan pada $b += $a = $b-$apengulangan klasik yang berfungsi sebagai berikut:

• Pada awal setiap loop $aberisi F(n-2)dan $bberisiF(n)
• Setelah $a = $b-$a $aberisiF(n-1)
• Setelah $b += $a $bberisiF(n+1)

Masalahnya di sini adalah inisialisasi. Cara klasik hanyalah $b += $a = $b-$a || 1urutannya1 2 3 5 ...

Dengan memperluas urutan fibonacci ke kiri:

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

Anda melihat bahwa titik awal yang tepat adalah $a = -1dan $b = 0. Inisialisasi $ a dapat dikombinasikan dengan mengatur loop

Akhirnya ganti $adengan $;untuk menyingkirkan ruang sebelumfor

Saya bisa memberi Anda solusi Python dua baris. Ini akan mengembalikan mereka sebagai daftar.

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)

Anda bisa mencetaknya dengan menambahkan peta lain untuk membuatnya menjadi string dan kemudian menambahkan gabungan, tapi itu sepertinya tidak perlu bagi saya.

Sayangnya saya tidak tahu bagaimana memasukkan lambda rekursif map, jadi saya terjebak di dua baris.

Python (78 karakter)

Saya menggunakan rumus Binet untuk menghitung angka fibonacci -

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

Ini tidak sekecil beberapa jawaban lain di sini, tetapi anak itu cepat

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

Skema

Ini dioptimalkan menggunakan rekursi ekor:

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

Bukti bahwa itu berhasil .

J, 25 karakter

Saya menyadari bahwa solusi J mungkin bukan apa yang Anda cari, tetapi inilah satu. :-)

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

Pemakaian:

    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

Bagaimana itu bekerja:

Mulai dari kanan (karena program J dibaca dari kanan ke kiri),

2-~ 6The ~Operator membalikkan argumen untuk kata kerja jadi ini adalah sama dengan6-2

Mengabaikan bagian dalam tanda kurung untuk saat ini, 0 1(...)@[&0~ xmengambil kata kerja dalam tanda kurung dan mengeksekusi xkali menggunakan daftar 0 1sebagai input - ~lagi membalikkan argumen di sini, memberi x (...)@[&0 ] 0 1, berarti saya dapat menyimpan input di akhir fungsi.

Di dalam kurung ada garpu ],+/&(_2&{.)yang terdiri dari tiga kata kerja - ], ,dan +/&(_2&{.).

Garpu mengambil tiga kata kerja a b cdan menggunakannya seperti ini: di (x a y) b (x c y)mana xdan ymerupakan argumen ke garpu. The ,adalah kata kerja pusat di garpu ini dan bergabung dengan hasil x ] ydan x +/&(_2&{.) ybersama-sama.

]mengembalikan argumen kiri tidak diubah sehingga x ] ydievaluasi menjadi x.

+/&(_2&{.)mengambil dua item terakhir dari daftar yang diberikan (_2&{.)- dalam hal ini 0 1- dan kemudian menambahkannya bersama-sama +/( &hanya bertindak sebagai lem).

Setelah kata kerja telah beroperasi begitu hasilnya dimasukkan kembali untuk menjalankan berikutnya, menghasilkan urutan.

TI-Basic, 43 karakter

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

Kode ini dapat langsung dimasukkan ke program utama, atau dibuat menjadi program terpisah yang direferensikan oleh yang pertama.

APL (33)

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

Pemakaian:

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

Python (55)

a,b=0,1

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

Powershell - 35 karakter

Powershell menerima input pipa , jadi saya berkeyakinan bahwa n |masuk n | <mycode>tidak boleh bertentangan dengan hitungan saya, tetapi sebaliknya hanya bagian dari memulai "fungsi" dalam bahasa.

Solusi pertama mengasumsikan kita mulai dari 0:

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

Solusi kedua mengasumsikan kita dapat mulai dari 1:

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

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

Hasil:

1
1
2
3
5

Menariknya, upaya untuk menghindari overhead dari for()lingkaran mengakibatkan jumlah karakter yang sama: %{$2=1;iex('($1=($2+=$1)-$1);'*$_)}.

Python, 43 karakter

Berikut adalah tiga liner yang berbeda secara fundamental yang tidak menggunakan formula 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

Saya tidak pernah disalahgunakan dengan reducebegitu buruk.

dc, 32 karakter:

Ini sebenarnya akan selalu menunjukkan dua yang pertama, jadi fungsi hanya berfungsi seperti yang diharapkan untuk N> = 2 .

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

C, 75 karakter:

Tidak sekeren jawaban yang diterima, tetapi lebih pendek dan lebih cepat:

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

CL, 64 karakter:

Salah satu bookmark saya yang paling sering digunakan semester ini memiliki contoh menarik yang lebih pendek daripada banyak yang lain di sini, dan itu hanya permohonan langsung dari loopmakro - pada dasarnya hanya satu pernyataan! Melucuti itu untuk semua spasi putih yang saya bisa:

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

Cukup singkat, dan menyenangkan serta mudah dibaca! Untuk membaca input, n (termasuk spasi putih di sekitarnya) dapat diganti dengan (read), menambahkan 3 karakter.

SALAH, 28 byte

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

Python 2, 38 Bytes

Peningkatan pada solusi yang diposting sebelumnya:

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

Ini menggunakan execdan menggandakan string untuk menghindari loop.

Python 3, 46 Bytes

Tidak cukup efisien dalam Python 3:

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

C99, 58 karakter

Fungsi berikut mengisi array bilangan bulat dengan nilai pertama ndari deret Fibonacci yang dimulai dengan 0.

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

Uji harness, dengan nargumen argumen perintah:

#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 dalam 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))):'';}

Penggunaan array_sumdan fungsi rekursif untuk menghasilkan seri.

Misalnya:

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

Scala, 65 karakter

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

Ini mencetak, misalnya, 9 angka Fibonacci pertama. Untuk versi yang lebih bisa digunakan mengambil panjang urutan dari input konsol, diperlukan 70 karakter:

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

Waspadai penggunaan Range yang membatasi ini hingga nilai Int.

Q 24

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

Pertama dan nomor fibonacci

Lua, 85 byte

Saya belajar Lua jadi saya ingin menambahkan bahasa ini ke kolam.

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

dan semuanya mengambil 85 karakter, dengan parameter sebagai argumen baris perintah. Poin bagus lainnya adalah mudah dibaca.

SALAH, 20 karakter

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

Masukan harus ada di tumpukan sebelum menjalankan ini.

Pyt , 3 byte

ř⁻Ḟ

Cobalah online!

ř membuat larik [1, 2, 3, ..., x]
⁻ Mengurangi setiap item satu kali (karena Ḟ diindeks 0)
Ḟ untuk setiap item dalam x mengkonversikannya menjadi setara dengan fibonacci

kode mesin x86 - 379 byte

Versi dengan header ELF yang mencetak 484 byte:

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

Versi tanpa judul (yang harus dinilai):

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$