Послідовність Фібоначчі - це послідовність чисел, де кожне число у послідовності є сумою двох чисел, що передують їй. Перші два числа в послідовності є обома 1.

Ось кілька перших термінів

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

Напишіть найкоротший код, який:

• Створює послідовність Фібоначчі без кінця.

• Дано nобчислює nй термін послідовності. (1 або нульове значення)

Ви можете використовувати стандартні форми введення та виводу.

(Я дав обидва варіанти на випадок, якщо один простіше зробити на вибраній вами мові, ніж інший.)

Для функції, яка приймає n, слід підтримувати досить велике повернене значення (найбільше число Фібоначчі, що відповідає мінімальному розміру слова вашого комп'ютера, як мінімум).

Таблиця лідерів

/* 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 символів:

Анонімний нескінченний список послідовностей фільонок:

^2,*+*...*

Такий же, як:

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

Отже, ви можете призначити його масиву:

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

або

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

І отримайте перші одинадцять значень (від 0 до 10) за допомогою:

say @short-fibs[^11];

або з:

say @fibs[^11];

Зачекайте, ви також можете отримати перші 50 номерів з анонімного списку:

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

Це повертає:

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

І кілька простих орієнтирів:

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

З:

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

EOF

Брейнфук, 22 удари

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

Створює послідовність Фібоначчі, поступово рухаючись по стрічці пам'яті.

Haskell, 17 15 14 символів

f=1:scanl(+)1f

Спробуйте в Інтернеті!

C # 4, 58 байт

Потік (69; 65 при слабкому наборі IEnumerable)

(Припускаючи usingдирективу для System.Collections.Generic.)

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

Одиничне значення (58)

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

GolfScript, 12

Зараз всього 12 символів!

1.{.@.p+.}do

> <> - 15 символів

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

J, 10 символів

Використовуючи вбудований розрахунок коефіцієнтів серії Тейлора, тому, можливо, мало обманливо. Дізналися тут .

   (%-.-*:)t.

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

Шестикутник ,18 14 12

Дякую Мартіну за 6 байт!

1="/}.!+/M8;

Розширено:

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

Спробуйте в Інтернеті

Старий, відповідай. Це не вдається, оскільки зображення та пояснення можуть бути корисними новим користувачам Hexagony.

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

Розширено:

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

Це друкує послідовність Фібоначчі, розділену новими рядками.

Спробуйте в Інтернеті! Будьте уважні, однак інтернет-перекладач не дуже любить нескінченний вихід.

Пояснення

У цій програмі є дві "підпрограми", кожна з яких управляється одним із двох використаних IP-адрес. Перший розпорядок друкує нові рядки, а другий здійснює обчислення та вихід Фібоначчі.

Перша підпрограма починається з першого рядка і весь час рухається вліво вправо. Він спочатку друкує значення вказівника пам'яті (ініціалізований до нуля), а потім збільшує значення вказівника пам'яті на 1. Після відключення IP-адреси переходить до третього рядка, який спочатку переходить на іншу комірку пам'яті, після чого друкує новий рядок. Оскільки новий рядок має позитивне значення (його значення 10), код завжди переходитиме до п’ятого рядка, наступного. П'ятий рядок повертає вказівник пам'яті на наше число Фібоначчі, а потім переходить на іншу підпрограму. Коли ми повернемося з цієї підпрограми, IP-код відскакує назад до третього рядка, виконавши не-оп.

Друга підпрограма починається у верхньому правому куті і починає рух на південний схід. Після безреактивного руху нам відбивається Захід по другій лінії. Цей рядок друкує поточне число Фібоначчі перед переміщенням вказівника пам'яті на наступне місце. Потім IP переходить до четвертого рядка, де він обчислює наступне число Фібоначчі, використовуючи попередні два. Потім він повертає управління до першої підпрограми, але коли вона повертається до управління програмою, вона продовжується, поки не зустріне стрибок, де вона відскакує над дзеркалом, яке спочатку використовувалося для вказівки на захід, оскільки повертається до другого рядка.

Попередні гарні картинки!

Ліва частина зображення - програма, права частина - пам'ять. Синє поле - це перший IP, і обидва IP-адреси вказують на наступну інструкцію, яку потрібно виконати.

Примітка. Малюнки можуть здаватися досить людям, які мають подібні обмежені вміння з програмами редагування зображень: PI додасть принаймні ще 2 ітерації, щоб використання *оператора стало більш зрозумілим.

Примітка 2: Відповідь алефальфи я побачив лише після написання більшості цього, я зрозумів, що він все ще цінний через розлуку, але фактичні частини Фібоначчі в наших програмах дуже схожі. Крім того, це найменша програма з шестикутниками, яку я бачив, використовуючи більше ніж один IP, тому я подумав, що все-таки варто було б зберегти: P

КОРО , 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 байти

Python, використовуючи рекурсію ... тут з'являється StackOverflow!

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

Желе , 3 байти

+¡1

Спробуйте в Інтернеті!

Як це працює

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

^‡ ¡ визирає на дві ланки зліва. Оскільки існує лише одне, воно повинно бути тілом петлі. Тому з введення читається число. Оскільки аргументів командного рядка немає, це число зчитується з STDIN.

Гольфскрипт - єдиний номер - 12/11/10

12 символів для отримання даних від stdin:

~0 1@{.@+}*;

11 символів для введення вже в стеку:

0 1@{.@+}*;

10 символів для подальшого визначення 1 як 0-го числа Фібоначчі:

1.@{.@+}*;

Рубін

29 27 25 24 символів

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

Редагувати: зробив це нескінченним циклом. ;)

Математика, 9 чол

Fibonacci

Якщо вбудовані функції заборонені, ось чітке рішення:

Математика, 33 32 31 ряд

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

DC (20 байт)

Як бонус, це навіть заплутано;)

zzr[dsb+lbrplax]dsax

EDIT: Я можу зазначити, що він друкує всі цифри у послідовності поля, якщо ви чекаєте досить довго.

Прелюдія , 12 байт

Один з небагатьох викликів, де Prelude насправді є досить конкурентоспроможним:

1(v!v)
  ^+^

Для цього потрібен інтерпретатор Python який друкує значення у вигляді десяткових чисел замість символів.

Пояснення

У прелюдії всі рядки виконуються паралельно з вказівниками проходження вказівника, що проходить через програму. Кожен рядок має свій стек, який ініціалізується на нуль.

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.

Цикл повторюється назавжди, тому що перший стек ніколи не матиме a 0 вершини.

Зауважте, що це починається з послідовності Фібоначчі 0.

Шестикутник , 6 байт

Неконкурентований, оскільки мова новіша, ніж питання.

1.}=+!

Безголовки:

  1 .
 } = +
  ! .

Він друкує послідовність Фібоначчі без жодного роздільника.

TI-BASIC, 11

Легендарний гольфіст TI-BASIC Кеннет Хаммонд ("Weregoose") з цього сайту . Працює в O (1) час і вважає 0 0-м членом послідовності Фібоначчі.

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

Використовувати:

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

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

Як це працює? Якщо ви займаєтеся математикою, виявляється, що sinh‾¹(.5)це дорівнює ln φ, тому це модифікована версія формули Біне, яка округляється вниз, а не використовує (1/φ)^nтермін корекції. Для round(запобігання помилок округлення необхідний (до 9 знаків після коми).

К - 12

Обчислює число nі n-1число Фібоначчі.

{x(|+\)/0 1}

Просто число nthФібоначчі.

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

Джулія, 18 байт

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

Ява, 55

Я не можу конкурувати з лаконічністю більшості мов тут, але можу запропонувати істотно інший і, можливо, набагато швидший (постійний час) спосіб обчислення n-го числа:

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

n- це вхід (int або long), починаючи з n = 1. Він використовує формулу Біне і округляє замість віднімання.

Рубін, 25 годин

Відповідь st0le скорочена.

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

FAC: функціональний APL, 4 символи (!!)

Не моя, тому розміщена як вікі спільноти. FAC - це діалект APL, який Гай-Чен Ту, очевидно, запропонував в якості докторської дисертації в 1985 році. Пізніше він написав статтю разом з Аланом Дж. Перлісом під назвою " FAC: Функціональна мова APL ". Цей діалект APL використовує "ледачі масиви" та допускають масиви нескінченної довжини. Він визначає оператор "iter" (⌼ ) для забезпечення компактного визначення деяких рекурсивних послідовностей.

Монадичний («унарний») випадок - ⌼це в основному Хаскелл iterate, і визначається як (F⌼) A ≡ A, (F A), (F (F A)), …. Диадического ( «двійковий») випадку визначається кілька аналогічно для двох змінних: A (F⌼) B ≡ A, B, (A F B), (B F (A F B)), …. Чому це корисно? Ну, як виявляється, саме такий тип рецидивів має послідовність Фібоначчі. Насправді один із наведених прикладів - це

1+⌼1

виробляючи звичну послідовність 1 1 2 3 5 8 ….

Отже, ось, можливо, найкоротша можлива реалізація Фібоначчі мовою програмування, що не є новизною. : D

R, 40 байт

Рішення R не бачили, тож:

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

05AB1E, 7 байт

Код:

1$<FDr+

Спробуйте в Інтернеті!

Додо , 26 байт

	dot F
F
	F dip
	F dip dip

Спробуйте в Інтернеті!

Як це працює

Функція F виконує всі важкі підйоми; вона визначається рекурсивно наступним чином.

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

Щоразу, коли n> 1 , маємо | n - 1 | = n - 1 <n і || n - 1 | - 1 | = | n - 1 - 1 | = n - 2 <n , тому функція повертається (F (n - 1), F (n - 2)) .

Якщо n = 0 , то | n - 1 | = 1> 0 ; якщо n = 1 , то || n - 1 | - 1 | = | 0 - 1 | = 1 = 1 . В обох випадках спроби рекурсивних викликів F (1) викликають виключення " Передача" , тому F (0) повертає 0, а F (1) повертає 1 .

Наприклад, F (3) = (F (1), F (2)) = (1, F (0), F (1)) = (1, 0, 1) .

Нарешті, основна функція визначається як

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

тому він додає всі координати вектора, поверненого F .

Наприклад, main (3) = sum (F (3)) = sum (1, 0, 1) = 2 .

GolfScript, 13 символів

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

(Моя відповідь з попереднього запитання про переповнення стека .)

Десмос , 61 байт

Гольф

Натисніть add sliderкнопку для n.

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

Останній рядок - вихід.

Безумовно

Це функція.

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

Cubix , 10 байт

Неконкурентна відповідь, оскільки мова новіша за питання.

Cubix - це нова двовимірна мова від @ETHproductions, якщо код загорнутий на куб розміром з розміром.

;.o.ON/+!)

Спробуйте в Інтернеті

Це загортається на куб 2 х 2 наступним чином

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

• O вивести значення TOS
• N натисніть нову лінію на стек
• / відбивати північ
• o вивести символ TOS
• ; поп TOS
• / відбиватися на схід після обходу куба
• + додайте топ 2 значення стека
• ! пропустити наступну команду, якщо TOS дорівнює 0
• ) збільшення TOS на 1. Це суттєво стартує послідовність.

Це нескінченний цикл, який друкує послідовність з роздільником нового рядка. Скористайтеся тим, що більшість команд не спливає значення зі стека.
Якщо роздільник ігнорується, то це можна зробити за допомогою 5 байт.O+!)

Brainfuck, 16,15, 14/13 символів

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

Створює послідовність Фібоначчі і нічого не друкує. Крім того, він коротший, ніж вище.

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

Цей символ містить 14 символів, але виводить символи ASCII зі значеннями послідовності Фібоначчі.