Chuỗi Fibonacci là một chuỗi các số, trong đó mỗi số trong chuỗi là tổng của hai số trước nó. Hai số đầu tiên trong chuỗi là cả 1.

Dưới đây là một vài điều khoản đầu tiên

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

Viết mã ngắn nhất:

• Tạo chuỗi Fibonacci không có kết thúc.

• Cho ntính toán số hạng nthứ tự của dãy. (1 hoặc 0 được lập chỉ mục)

Bạn có thể sử dụng các hình thức đầu vào và đầu ra tiêu chuẩn.

(Tôi đã đưa ra cả hai tùy chọn trong trường hợp một tùy chọn dễ thực hiện bằng ngôn ngữ bạn đã chọn hơn ngôn ngữ khác.)

Đối với hàm lấy một ngiá trị trả về lớn một cách hợp lý (số Fibonacci lớn nhất phù hợp với kích thước từ thông thường của máy tính của bạn, ở mức tối thiểu) phải được hỗ trợ.

Bảng xếp hạng

/* 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 ký tự:

Danh sách chuỗi vô danh vô danh:

^2,*+*...*

Giống như:

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

Vì vậy, bạn có thể gán nó cho một mảng:

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

hoặc là

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

Và nhận mười một giá trị đầu tiên (từ 0 đến 10) với:

say @short-fibs[^11];

Hoặc với:

say @fibs[^11];

Đợi đã, bạn có thể nhận được 50 số đầu tiên từ chính danh sách ẩn danh:

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

Điều đó trả về:

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

Và một số điểm chuẩn đơn giản:

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

Với:

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

EOF

Brainfuck, 22 nét

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

Tạo chuỗi Fibonacci dần dần di chuyển trên băng nhớ.

Haskell, 17 15 14 ký tự

f=1:scanl(+)1f

Hãy thử trực tuyến!

C # 4, 58 byte

Luồng (69; 65 nếu gõ yếu IEnumerable)

(Giả sử một usingchỉ thị cho System.Collections.Generic.)

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

Giá trị đơn (58)

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

GolfScript, 12

Bây giờ, chỉ có 12 ký tự!

1.{.@.p+.}do

> <> - 15 ký tự

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

J, 10 ký tự

Sử dụng tính toán tích hợp của các hệ số chuỗi Taylor nên có thể ít gian lận. Đã học nó ở đây .

   (%-.-*:)t.

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

Lục giác ,18 14 12

Cảm ơn Martin cho 6 byte!

1="/}.!+/M8;

Mở rộng:

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

Dùng thử trực tuyến

Cũ, trả lời. Điều này đang được để lại vì hình ảnh và lời giải thích có thể hữu ích cho người dùng Hexagony mới.

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

Mở rộng:

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

Điều này in ra chuỗi Fibonacci được phân tách bằng các dòng mới.

Hãy thử trực tuyến! Hãy cẩn thận, trình thông dịch trực tuyến không thực sự thích đầu ra vô hạn.

Giải trình

Có hai "chương trình con" cho chương trình này, mỗi chương trình được điều hành bởi một trong hai IP được sử dụng. Thường trình đầu tiên in các dòng mới, và thứ hai thực hiện tính toán và đầu ra Fibonacci.

Chương trình con đầu tiên bắt đầu trên dòng đầu tiên và di chuyển từ trái sang phải toàn bộ thời gian. Đầu tiên, nó in giá trị tại con trỏ bộ nhớ (được khởi tạo thành 0), sau đó tăng giá trị tại con trỏ bộ nhớ theo 1. Sau khi không hoạt động, IP nhảy sang dòng thứ ba, đầu tiên chuyển sang một ô nhớ khác, sau đó in một dòng mới. Vì một dòng mới có giá trị dương (giá trị của nó là 10), mã sẽ luôn nhảy đến dòng thứ năm, tiếp theo. Dòng thứ năm trả về con trỏ bộ nhớ cho số Fibonacci của chúng tôi và sau đó chuyển sang chương trình con khác. Khi chúng tôi quay trở lại từ chương trình con này, IP sẽ quay trở lại dòng thứ ba, sau khi thực hiện lệnh cấm.

Chương trình con thứ hai bắt đầu ở góc trên bên phải và bắt đầu di chuyển về phía Đông Nam. Sau khi không hoạt động, chúng tôi bị trả về để đi về phía Tây dọc theo tuyến thứ hai. Dòng này in số Fibonacci hiện tại, trước khi di chuyển con trỏ bộ nhớ đến vị trí tiếp theo. Sau đó, IP nhảy đến dòng thứ tư, trong đó nó tính toán số Fibonacci tiếp theo bằng cách sử dụng hai số trước đó. Sau đó, nó đưa điều khiển trở lại chương trình con đầu tiên, nhưng khi lấy lại quyền kiểm soát chương trình, nó tiếp tục cho đến khi nó gặp một bước nhảy, trong đó nó nảy qua gương ban đầu được sử dụng để chỉ về phía Tây, khi nó quay trở lại dòng thứ hai.

Hình ảnh đẹp sơ bộ!

Phía bên trái của hình ảnh là chương trình, phía bên phải đại diện cho bộ nhớ. Hộp màu xanh là IP đầu tiên và cả hai IP đều trỏ vào lệnh tiếp theo sẽ được thực thi.

Lưu ý: Hình ảnh chỉ có thể xuất hiện đẹp đối với những người có kỹ năng hạn chế tương tự với các chương trình chỉnh sửa hình ảnh: PI sẽ thêm ít nhất 2 lần lặp lại để việc sử dụng *toán tử trở nên rõ ràng hơn.

Lưu ý 2: Tôi chỉ thấy câu trả lời của alephalpha sau khi viết hầu hết những điều này, tôi cho rằng nó vẫn còn giá trị vì sự tách biệt, nhưng các phần Fibonacci thực tế của các chương trình của chúng tôi rất giống nhau. Ngoài ra, đây là chương trình Hexagony nhỏ nhất mà tôi đã thấy sử dụng nhiều hơn một IP, vì vậy tôi nghĩ rằng dù sao cũng có thể giữ được: P

COW , 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, sử dụng đệ quy ... ở đây có StackOverflow!

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

Thạch , 3 byte

+¡1

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

^‡ ¡ peeks tại hai liên kết bên trái. Vì chỉ có một, nó phải là phần thân của vòng lặp. Do đó, một số được đọc từ đầu vào. Vì không có đối số dòng lệnh, số đó được đọc từ STDIN.

Golfscript - số duy nhất - 12/11/10

12 ký tự để lấy đầu vào từ stdin:

~0 1@{.@+}*;

11 ký tự cho đầu vào đã có trên ngăn xếp:

0 1@{.@+}*;

10 ký tự để xác định thêm 1 là số Fibonacci thứ 0:

1.@{.@+}*;

Hồng ngọc

29 27 25 24 Chars

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

Chỉnh sửa: làm cho nó một vòng lặp vô hạn. ;)

Toán học, 9 ký tự

Fibonacci

Nếu các chức năng tích hợp không được phép, đây là một giải pháp rõ ràng:

Toán học, 33 32 31 ký tự

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

DC (20 byte)

Như một phần thưởng, nó thậm chí còn bị xáo trộn;)

zzr[dsb+lbrplax]dsax

EDIT: Tôi có thể chỉ ra rằng nó in tất cả các số trong chuỗi Wikipedia, nếu bạn chờ đủ lâu.

Mở đầu , 12 byte

Một trong số ít những thách thức mà Prelude thực sự khá cạnh tranh:

1(v!v)
  ^+^

Điều này đòi hỏi trình thông dịch Python in các giá trị dưới dạng số thập phân thay vì ký tự.

Giải trình

Trong Prelude, tất cả các dòng được thực thi song song, với các con trỏ lệnh đi ngang qua các cột của chương trình. Mỗi dòng có ngăn xếp riêng được khởi tạo bằng không.

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.

Vòng lặp lặp lại mãi mãi, bởi vì ngăn xếp đầu tiên sẽ không bao giờ có 0đỉnh.

Lưu ý rằng điều này bắt đầu chuỗi Fibonacci từ 0.

Lục giác , 6 byte

Không cạnh tranh vì ngôn ngữ mới hơn câu hỏi.

1.}=+!

Ung dung:

  1 .
 } = +
  ! .

Nó in chuỗi Fibonacci mà không có bất kỳ dấu phân cách nào.

TI-BASIC, 11

Bởi tay golf huyền thoại TI-BASIC Kenneth Hammond ("Weregoose"), từ trang web này . Chạy trong thời gian O (1) và coi 0 là số hạng 0 của chuỗi Fibonacci.

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

Để sử dụng:

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

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

Cái này hoạt động ra sao? Nếu bạn làm toán, hóa ra nó sinh‾¹(.5)bằng ln φ, vì vậy đây là phiên bản sửa đổi của công thức Binet làm tròn thay vì sử dụng (1/φ)^nthuật ngữ chỉnh sửa. Các round((vòng đến 9 chữ số thập phân) là cần thiết để ngăn chặn các lỗi làm tròn.

K - 12

Tính số nvà n-1số Fibonacci.

{x(|+\)/0 1}

Chỉ là nthsố Fibonacci.

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

Julia, 18 byte

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

Java, 55

Tôi không thể cạnh tranh với sự đồng nhất của hầu hết các ngôn ngữ ở đây, nhưng tôi có thể cung cấp một cách khác biệt đáng kể và có thể nhanh hơn nhiều (thời gian không đổi) để tính số thứ n:

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

nlà đầu vào (int hoặc long), bắt đầu bằng n = 1. Nó sử dụng công thức và vòng của Binet thay vì phép trừ.

Ruby, 25 ký tự

Câu trả lời của st0le rút ngắn.

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

FAC: APL chức năng, 4 ký tự (!!)

Không phải của tôi, do đó được đăng dưới dạng wiki cộng đồng. FAC là một phương ngữ của APL mà Hai-Chen Tu dường như đã đề xuất làm luận án tiến sĩ năm 1985. Sau đó, ông đã viết một bài báo cùng với Alan J. Perlis gọi là " FAC: A APL Language Functional ". Phương ngữ này của APL sử dụng "mảng lười biếng" và cho phép các mảng có độ dài vô hạn. Nó định nghĩa một toán tử "iter" ( ⌼) để cho phép định nghĩa nhỏ gọn của một số chuỗi đệ quy.

Trường hợp đơn nguyên ("đơn nguyên") ⌼về cơ bản là của Haskell iterate, và được định nghĩa là (F⌼) A ≡ A, (F A), (F (F A)), …. Trường hợp dyadic ("nhị phân") được định nghĩa tương tự cho hai biến : A (F⌼) B ≡ A, B, (A F B), (B F (A F B)), …. Tại sao điều này hữu ích? Chà, hóa ra đây chính xác là kiểu tái phát của chuỗi Fibonacci. Trong thực tế, một trong những ví dụ được đưa ra là

1+⌼1

sản xuất trình tự quen thuộc 1 1 2 3 5 8 ….

Vì vậy, bạn đi, rất có thể là triển khai Fibonacci ngắn nhất có thể trong một ngôn ngữ lập trình không mới lạ. :CƯỜI MỞ MIỆNG

R, 40 byte

Không thấy giải pháp R, vì vậy:

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

05AB1E, 7 byte

Mã số:

1$<FDr+

Hãy thử trực tuyến!

Dodos , 26 byte

	dot F
F
	F dip
	F dip dip

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Hàm F thực hiện tất cả các công việc nặng; nó được định nghĩa đệ quy như sau.

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

Bất cứ khi nào n> 1 , chúng ta có | n - 1 | = n - 1 <n và | | n - 1 | - 1 | = | n - 1 - 1 | = n - 2 <n , do đó hàm trả về (F (n - 1), F (n - 2)) .

Nếu n = 0 , thì | n - 1 | = 1> 0 ; nếu n = 1 , thì | | n - 1 | - 1 | = | 0 - 1 | = 1 = 1 . Trong cả hai trường hợp, các lệnh gọi đệ quy đã cố gắng F (1) đưa ra một ngoại lệ Surrender , do đó F (0) trả về 0 và F (1) trả về 1 .

Ví dụ: F (3) = (F (1), F (2)) = (1, F (0), F (1)) = (1, 0, 1) .

Cuối cùng, chức năng chính được định nghĩa là

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

do đó nó cho biết thêm lên tất cả các tọa độ của vector được trả về bởi F .

Ví dụ: main (3) = sum (F (3)) = sum (1, 0, 1) = 2 .

GolfScript, 13 ký tự

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

(Câu trả lời của tôi từ câu hỏi Stack Overflow trước đó .)

Desmos , 61 byte

Chơi gôn

Nhấn vào add slidernút cho n.

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

Dòng cuối cùng là đầu ra.

Bị đánh cắp

Là một chức năng.

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

Khối , 10 byte

Câu trả lời không cạnh tranh vì ngôn ngữ mới hơn câu hỏi.

Cubix là một ngôn ngữ 2 chiều mới bởi @ETHproductions là mã được bọc trên một khối có kích thước phù hợp.

;.o.ON/+!)

Dùng thử trực tuyến

Điều này kết thúc vào một khối 2 x 2 theo cách sau

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

• O xuất giá trị của ĐKDV
• N đẩy dòng mới lên ngăn xếp
• / phản ánh phía bắc
• o xuất ra đặc tính của ĐKDV
• ; nhạc pop
• / phản xạ về phía đông sau khi đi xung quanh khối lập phương
• + thêm 2 giá trị hàng đầu của ngăn xếp
• ! bỏ qua lệnh tiếp theo nếu TOS bằng 0
• ) tăng ĐKDV lên 1. Điều này khởi động trình tự cơ bản.

Đây là một vòng lặp vô tận in chuỗi bằng một dấu phân cách dòng mới. Nó lợi dụng thực tế là hầu hết các lệnh không bật các giá trị từ ngăn xếp.
Nếu dấu phân cách bị bỏ qua thì điều này có thể được thực hiện với 5 byte.O+!)

Brainfuck, 16,15, 14/13 ký tự

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

Tạo chuỗi Fibonacci và không in ra bất cứ điều gì. Ngoài ra, là ngắn hơn so với ở trên.

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

Cái này có 14 ký tự nhưng in ra các ký tự ASCII với các giá trị của chuỗi Fibonacci.