The deret Fibonacci adalah urutan angka, di mana setiap nomor dalam urutan adalah jumlah dari dua angka sebelumnya itu. Dua angka pertama dalam urutan keduanya adalah 1.

Inilah beberapa istilah pertama

1 1 2 3 5 8 13 21 34 55 89 ...

Tulis kode terpendek yang baik:

• Menghasilkan urutan Fibonacci tanpa akhir.

• Diberi nmenghitung njangka waktu urutan. (Baik 1 atau nol diindeks)

Anda dapat menggunakan bentuk input dan output standar.

(Saya memberikan kedua opsi jika salah satu lebih mudah dilakukan dalam bahasa yang Anda pilih daripada yang lain.)

Untuk fungsi yang membutuhkan n, nilai pengembalian yang cukup besar (angka Fibonacci terbesar yang sesuai dengan ukuran kata normal komputer Anda, minimal) harus didukung.

Papan peringkat

/* Configuration */

var QUESTION_ID = 85; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 3; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    else console.log(body);
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    lang = jQuery('<a>'+lang+'</a>').text();
    
    languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
    if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body {
  text-align: left !important;
  display: block !important;
}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/all.css?v=ffb5d0584c5f">
<div id="language-list">
  <h2>Shortest Solution by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

Perl 6, 10 karakter:

Daftar urutan fibonacci tak terbatas anonim:

^2,*+*...*

Sama dengan:

0, 1, -> $x, $y { $x + $y } ... Inf;

Jadi, Anda bisa menetapkannya ke array:

my @short-fibs = ^2, * + * ... *;

atau

my @fibs = 0, 1, -> $x, $y { $x + $y } ... Inf;

Dan dapatkan sebelas nilai pertama (dari 0 hingga 10) dengan:

say @short-fibs[^11];

atau dengan:

say @fibs[^11];

Tunggu, Anda bisa mendapatkan juga 50 nomor pertama dari daftar anonim itu sendiri:

say (^2,*+*...*)[^50]

Itu kembali:

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765
10946 17711 28657 46368 75025 121393 196418 317811 514229 832040
1346269 2178309 3524578 5702887 9227465 14930352 24157817 39088169
63245986 102334155 165580141 267914296 433494437 701408733 1134903170 
1836311903 2971215073 4807526976 7778742049

Dan beberapa tolok ukur sederhana:

real    0m0.966s
user    0m0.842s
sys     0m0.080s

Dengan:

$ time perl6 -e 'say (^2, *+* ... *)[^50]'

EOF

Brainfuck, 22 pukulan

+>++[-<<[->+>+<<]>>>+]

Menghasilkan urutan Fibonacci secara bertahap bergerak melintasi pita memori.

Haskell, 17 15 14 karakter

f=1:scanl(+)1f

Cobalah online!

C # 4, 58 byte

Streaming (69; 65 jika diketik dengan lemah IEnumerable)

(Dengan asumsi usingarahan untuk System.Collections.Generic.)

IEnumerable<int>F(){int c=0,n=1;for(;;){yield return c;n+=c;c=n-c;}}

Nilai tunggal (58)

int F(uint n,int x=0,int y=1){return n<1?x:F(n-1,y,x+y);}

GolfScript, 12

Sekarang, hanya 12 karakter!

1.{.@.p+.}do

> <> - 15 karakter

0:nao1v LF a+@:n:<o

J, 10 karakter

Menggunakan perhitungan koefisien deret Taylor bawaan jadi mungkin sedikit curang. Belajar di sini .

   (%-.-*:)t.

   (%-.-*:)t. 0 1 2 3 4 5 10 100
0 1 1 2 3 5 55 354224848179261915075

Segi enam ,18 14 12

Terima kasih Martin untuk 6 byte!

1="/}.!+/M8;

Diperluas:

  1 = "
 / } . !
+ / M 8 ;
 . . . .
  . . .

Cobalah online

Tua, jawab. Ini dibiarkan masuk karena gambar dan penjelasannya mungkin bermanfaat bagi pengguna Hexagony baru.

!).={!/"*10;$.[+{]

Diperluas:

  ! ) .
 = { ! /
" * 1 0 ;
 $ . [ +
  { ] .

Ini mencetak urutan Fibonacci yang dipisahkan oleh baris baru.

Cobalah online! Namun berhati-hatilah, penerjemah online tidak terlalu menyukai hasil yang tidak terbatas.

Penjelasan

Ada dua "subrutin" untuk program ini, masing-masing dijalankan oleh salah satu dari dua IP yang digunakan. Rutin pertama mencetak baris baru, dan yang kedua melakukan perhitungan dan output Fibonacci.

Subrutin pertama dimulai pada baris pertama dan bergerak dari kiri ke kanan sepanjang waktu. Pertama mencetak nilai pada penunjuk memori (diinisialisasi ke nol), dan kemudian meningkatkan nilai pada penunjuk memori oleh 1. Setelah no-op, IP melompat ke baris ketiga yang pertama-tama beralih ke sel memori lain, kemudian mencetak baris baru. Karena baris baru memiliki nilai positif (nilainya 10), kode akan selalu melompat ke baris kelima, berikutnya. Baris kelima mengembalikan penunjuk memori ke nomor Fibonacci kami dan kemudian beralih ke subrutin lainnya. Ketika kami kembali dari subrutin ini, IP akan melompat kembali ke baris ketiga, setelah menjalankan no-op.

Subrutin kedua dimulai di sudut kanan atas dan mulai bergerak ke Tenggara. Setelah no-op, kita terpental untuk melakukan perjalanan ke Barat di sepanjang baris kedua. Baris ini mencetak angka Fibonacci saat ini, sebelum memindahkan penunjuk memori ke lokasi berikutnya. Kemudian IP melompat ke baris keempat, di mana ia menghitung angka Fibonacci berikutnya menggunakan dua sebelumnya. Ia kemudian memberikan kontrol kembali ke subrutin pertama, tetapi ketika ia mendapatkan kembali kendali atas program, ia melanjutkan hingga bertemu lompatan, di mana ia memantul di atas cermin yang awalnya digunakan untuk mengarahkannya ke Barat, saat ia kembali ke baris kedua.

Gambar-gambar Cantik Pendahuluan!

Sisi kiri gambar adalah program, sisi kanan mewakili memori. Kotak biru adalah IP pertama, dan kedua IP menunjuk pada instruksi selanjutnya yang akan dieksekusi.

Catatan: Gambar mungkin hanya tampak cantik bagi orang-orang yang memiliki keterampilan yang sama terbatasnya dengan program pengeditan gambar: PI akan menambahkan setidaknya 2 iterasi lebih banyak sehingga penggunaan *operator menjadi lebih jelas.

Catatan 2: Saya hanya melihat jawaban alephalpha setelah menulis sebagian besar dari ini, saya pikir itu masih berharga karena pemisahan, tetapi bagian Fibonacci sebenarnya dari program kami sangat mirip. Selain itu, ini adalah program Hexagony terkecil yang saya lihat menggunakan lebih dari satu IP, jadi saya pikir mungkin lebih baik untuk tetap menyimpannya: P

SAPI , 108

 MoO moO MoO mOo MOO OOM MMM moO moO
 MMM mOo mOo moO MMM mOo MMM moO moO
 MOO MOo mOo MoO moO moo mOo mOo moo

Python 2, 34 byte

Python, menggunakan rekursi ... inilah StackOverflow!

def f(i,j):print i;f(j,i+j)
f(1,1)

Jelly , 3 byte

+¡1

Cobalah online!

Bagaimana itu bekerja

+¡1    Niladic link. No implicit input.
       Since the link doesn't start with a nilad, the argument 0 is used.

  1    Yield 1.
+      Add the left and right argument.
 ¡     For reasons‡, read a number n from STDIN.
       Repeatedly call the dyadic link +, updating the right argument with
       the value of the left one, and the left one with the return value.

^‡ ¡ mengintip dua tautan ke kiri. Karena hanya ada satu, itu harus menjadi badan loop. Oleh karena itu, angka dibaca dari input. Karena tidak ada argumen baris perintah, angka itu dibaca dari STDIN.

Golfscript - nomor tunggal - 12/11/10

12 karakter untuk mengambil input dari stdin:

~0 1@{.@+}*;

11 karakter untuk input sudah ada di tumpukan:

0 1@{.@+}*;

10 karakter untuk mendefinisikan 1 lebih lanjut sebagai angka Fibonacci 0:

1.@{.@+}*;

Rubi

29 27 25 24 Karakter

p a=b=1;loop{b=a+a=p(b)}

Sunting: menjadikannya loop tak terbatas. ;)

Mathematica, 9 karakter

Fibonacci

Jika fungsi bawaan tidak diizinkan, berikut ini adalah solusi eksplisit:

Mathematica, 33 32 31 karakter

#&@@Nest[{+##,#}&@@#&,{0,1},#]&

DC (20 byte)

Sebagai bonus, itu bahkan dikaburkan;)

zzr[dsb+lbrplax]dsax

EDIT: Saya dapat menunjukkan bahwa itu mencetak semua angka dalam urutan fibonacci, jika Anda menunggu cukup lama.

Pendahuluan , 12 byte

Salah satu dari sedikit tantangan di mana Prelude sebenarnya cukup kompetitif:

1(v!v)
  ^+^

Ini membutuhkan juru bahasa Python yang mencetak nilai sebagai angka desimal alih-alih karakter.

Penjelasan

Di Prelude, semua baris dieksekusi secara paralel, dengan penunjuk instruksi melintasi kolom program. Setiap baris memiliki tumpukan sendiri yang diinisialisasi ke nol.

1(v!v)
  ^+^
| Push a 1 onto the first stack.
 | Start a loop from here to the closing ).
  | Copy the top value from the first stack to the second and vice-versa.
   | Print the value on the first stack, add the top two numbers on the second stack.
    | Copy the top value from the first stack to the second and vice-versa.

Pengulangan berulang selamanya, karena tumpukan pertama tidak akan pernah ada 0di atas.

Perhatikan bahwa ini mulai dari urutan Fibonacci 0.

Hexagony , 6 byte

Non-bersaing karena bahasa lebih baru daripada pertanyaan.

1.}=+!

Tidak Terkumpul:

  1 .
 } = +
  ! .

Ini mencetak urutan Fibonacci tanpa pemisah apa pun.

TI-BASIC, 11

Oleh pegolf TI-BASIC legendaris Kenneth Hammond ("Weregoose"), dari situs ini . Berjalan dalam waktu O (1), dan menganggap 0 sebagai istilah ke-0 dari deret Fibonacci.

int(round(√(.8)cosh(Anssinh‾¹(.5

Menggunakan:

2:int(round(√(.8)cosh(Anssinh‾¹(.5
                                     1

12:int(round(√(.8)cosh(Anssinh‾¹(.5
                                     144

Bagaimana cara kerjanya? Jika Anda menghitungnya, ternyata sinh‾¹(.5)sama dengan ln φ, jadi ini adalah versi modifikasi dari rumus Binet yang membulatkan ke bawah alih-alih menggunakan (1/φ)^nistilah koreksi. The round((bulat untuk 9 tempat desimal) diperlukan untuk mencegah kesalahan pembulatan.

K - 12

Menghitung ndan n-1angka Fibonacci.

{x(|+\)/0 1}

Hanya angka nthFibonacci.

{*x(|+\)/0 1}

Julia, 18 byte

n->([1 1;1 0]^n)[]

Jawa, 55

Saya tidak dapat bersaing dengan keringkasan sebagian besar bahasa di sini, tetapi saya dapat menawarkan cara yang jauh berbeda dan mungkin jauh lebih cepat (waktu konstan) untuk menghitung angka ke-n:

Math.floor(Math.pow((Math.sqrt(5)+1)/2,n)/Math.sqrt(5))

nadalah input (int atau panjang), dimulai dengan n = 1. Ini menggunakan rumus dan putaran Binet bukan pengurangan.

Ruby, 25 karakter

Jawaban st0le disingkat.

p 1,a=b=1;loop{p b=a+a=b}

FAC: APL Fungsional, 4 karakter (!!)

Bukan milik saya, karena itu diposting sebagai komunitas wiki. FAC adalah dialek APL yang tampaknya disarankan Hai-Chen Tu sebagai disertasi PhD-nya pada tahun 1985. Dia kemudian menulis sebuah artikel bersama dengan Alan J. Perlis yang disebut " FAC: A Functional APL Language ". Dialek APL ini menggunakan "array malas" dan memungkinkan array dengan panjang tak terbatas. Ini mendefinisikan operator "iter" ( ⌼) untuk memungkinkan definisi ringkas dari beberapa urutan rekursif.

Kasus monadik ("unary") ⌼pada dasarnya adalah kasus Haskell iterate, dan didefinisikan sebagai (F⌼) A ≡ A, (F A), (F (F A)), …. The diad ( "binary") kasus didefinisikan agak analog untuk dua variabel: A (F⌼) B ≡ A, B, (A F B), (B F (A F B)), …. Mengapa ini berguna? Nah, ternyata inilah jenis pengulangan yang dimiliki urutan Fibonacci. Bahkan, salah satu contoh yang diberikan adalah

1+⌼1

menghasilkan urutan yang akrab 1 1 2 3 5 8 ….

Jadi, begitulah, sangat mungkin implementasi Fibonacci terpendek dalam bahasa pemrograman yang tidak baru. : D

R, 40 byte

Belum melihat solusi R, jadi:

f=function(n)ifelse(n<3,1,f(n-1)+f(n-2))

05AB1E, 7 byte

Kode:

1$<FDr+

Cobalah online!

Dodos , 26 byte

	dot F
F
	F dip
	F dip dip

Cobalah online!

Bagaimana itu bekerja

Fungsi F melakukan semua pengangkatan berat; itu didefinisikan secara rekursif sebagai berikut.

F(n) = ( F(|n - 1|), F(||n - 1| - 1|) )

Setiap kali n> 1 , kita memiliki | n - 1 | = n - 1 <n dan || n - 1 | - 1 | = | n - 1 - 1 | = n - 2 <n , sehingga fungsinya kembali (F (n - 1), F (n - 2)) .

Jika n = 0 , maka | n - 1 | = 1> 0 ; jika n = 1 , maka || n - 1 | - 1 | = | 0 - 1 | = 1 = 1 . Dalam kedua kasus, upaya panggilan rekursif F (1) meningkatkan pengecualian Menyerah , sehingga F (0) mengembalikan 0 dan F (1) mengembalikan 1 .

Misalnya, F (3) = (F (1), F (2)) = (1, F (0), F (1)) = (1, 0, 1) .

Akhirnya, fungsi utama didefinisikan sebagai

main(n) = sum(F(n))

sehingga hal itu menambah semua koordinat vektor dikembalikan oleh F .

Misalnya, main (3) = jumlah (F (3)) = jumlah (1, 0, 1) = 2 .

GolfScript, 13 karakter

2,~{..p@+.}do

(Jawaban saya dari pertanyaan Stack Overflow sebelumnya .)

Desmos , 61 byte

Golf

Klik add slidertombol untuk n.

p=.5+.5\sqrt{5}
n=0
f=5^{-.5}\left(p^n-\left(-p\right)^{-n}\right)

Baris terakhir adalah output.

Tidak disatukan

Apakah fungsi.

\phi =\frac{1+\sqrt{5}}{2}
f_{ibonacci}\left(n\right)=\frac{\phi ^n-\left(-\phi \right)^{-n}}{\sqrt{5}}

Cubix , 10 byte

Jawaban tidak bersaing karena bahasa lebih baru daripada pertanyaan.

Cubix adalah bahasa 2 dimensi baru oleh @ ETHproductions adalah kode yang dibungkus ke dalam ukuran kubus agar sesuai.

;.o.ON/+!)

Cobalah online

Ini membungkus 2 x 2 kubus dengan cara berikut

    ; .
    o .
O N / + ! ) . .
. . . . . . . .
    . .
    . .

• O output nilai dari TOS
• N dorong baris baru ke tumpukan
• / mencerminkan utara
• o Keluarkan karakter dari TOS
• ; pop TOS
• / mencerminkan timur setelah berkeliling kubus
• + tambahkan 2 nilai teratas tumpukan
• ! lewati perintah berikutnya jika TOS adalah 0
• ) menambah TOS dengan 1. Ini memulai urutan pada dasarnya.

Ini adalah loop tanpa akhir yang mencetak urutan dengan pemisah baris baru. Itu mengambil keuntungan dari kenyataan bahwa sebagian besar perintah tidak memunculkan nilai dari stack.
Jika separator diabaikan maka ini dapat dilakukan dengan 5 byte.O+!)

Brainfuck, 16,15, 14/13 karakter

+[[->+>+<<]>]  

Menghasilkan urutan Fibonacci dan tidak mencetak apa pun. Juga, lebih pendek dari yang di atas.

+[.[->+>+<<]>]   

Yang ini memiliki 14 karakter tetapi mencetak karakter ASCII dengan nilai-nilai deret Fibonacci.