Нескінченне слово Фібоначчі є специфічним, нескінченна послідовність двійкових цифр, які обчислюються шляхом багаторазового конкатенації кінцевих двійкових слів.

Визначимо , що послідовність слів Фібоначчі типу (або FTW послідовність ) є будь-яка послідовність ⟨W _п ⟩ , який формується таким чином .

• Почніть з двох довільних масивів двійкових цифр. Назвемо ці масиви W _-1 і W ₀ .

• Для кожного n> 0 , нехай W _n ≔ W _n-1 ∥ W _n-2 , де ∥ позначає конкатенацію.

Наслідком рекурсивного визначення є те, що W _n - це завжди префікс W _{n + 1} і, отже, всіх W _k таких, що k> n . У певному сенсі, це означає послідовність ⟨W _п ⟩ сходиться до нескінченного слову.

Формально, нехай W _∞ бути єдиним нескінченним масив таким чином, що Ш _п є префіксом W _∞ для всіх п ≥ 0 .

Ми називатимемо будь-яке нескінченне слово, утворене вищевказаним процесом, нескінченним FTW .

Завдання

Напишіть програму або функцію, яка приймає два двійкові слова W _-1 і W ₀ вхідні як вхідні дані і друкує W _∞ , дотримуючись наступних, додаткових правил:

• Ви можете приймати слова в будь-якому порядку; як два масиви, масив масивів, два рядки, масив рядків або один рядок з роздільником, який ви обрали.

• Ви можете друкувати цифри нескінченного слова або без роздільника, або з послідовним роздільником між кожною парою сусідніх цифр.

• Припустимо, що у коду ніколи не залишиться пам’яті та його типи даних не переповнюються.

  Зокрема, це означає, що будь-який вихід до STDOUT або STDERR, який є результатом збоїв, буде ігнорований.

• Якщо я запускаю ваш код на моїй машині (Intel i7-3770, 16 GiB оперативної пам’яті, Fedora 21) протягом однієї хвилини і передаю його вихід wc -c, він повинен надрукувати щонайменше мільйон цифр W _∞ для (W _-1 , W ₀ ) = (1, 0) .

• Діють стандартні правила гольф-коду .

Приклад

Нехай W _-1 = 1 і W ₀ = 0 .

Тоді W ₁ = 01 , W ₂ = 010 , W ₃ = 01001 , W ₄ = 01001010 … і W _∞ = 010010100100101001010… .

Це нескінченне слово Фібоначчі.

Тестові справи

Усі тестові приклади містять перші 1000 цифр нескінченного FTW.

Input:  1 0
Output: 0100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001

Input:  0 01
Output: 0100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001

Input:  11 000
Output: 0001100000011000110000001100000011000110000001100011000000110000001100011000000110000001100011000000110001100000011000000110001100000011000110000001100000011000110000001100000011000110000001100011000000110000001100011000000110000001100011000000110001100000011000000110001100000011000110000001100000011000110000001100000011000110000001100011000000110000001100011000000110001100000011000000110001100000011000000110001100000011000110000001100000011000110000001100000011000110000001100011000000110000001100011000000110001100000011000000110001100000011000000110001100000011000110000001100000011000110000001100000011000110000001100011000000110000001100011000000110001100000011000000110001100000011000000110001100000011000110000001100000011000110000001100011000000110000001100011000000110000001100011000000110001100000011000000110001100000011000000110001100000011000110000001100000011000110000001100011000000110000001100011000000110000001100011000000110001100000011000000110001100000011000110000001100000011

Input:  10 010
Output: 0101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010

Input:  101 110
Output: 1101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101

Pyth, 8 байт

u,peGsGQ

Введіть у форму "W-1", "W0" .

Доказ завершення:

$ time pyth -cd 'u,peGsGQ' <<< '"1", "0"' 2>/dev/null | head -c1000000 > /dev/null

real    0m0.177s
user    0m0.140s
sys 0m0.038s

Доказ коректності:

Ось серія як внутрішньо генерована. Він друкується в конкатенації програмою.

[0, 10, 010, 10010, 01010010, 1001001010010,...]

Порівняйте з наступним, надрукованим конкатенацією, що є просто рядком, доданим до попереднього рядка на кожному кроці:

[0, 1, 0, 01, 010, 01001, 01001010, 0100101001001, ...]

Ми хочемо довести, що вони рівнозначні.

Зрозуміло, що вони однакові через перші кілька кроків. Давайте порівняємо їх трохи після:

010
  010

10010
  01001

01010010
  01001010

1001001010010
  0100101001001

Ми бачимо, що пари рядків мають по черзі форми:

01a 10b
a10 b01

Де a і b - довільні послідовності на 0s і 1s. Давайте трохи продовжимо послідовність, щоб довести, чи продовжується назавжди за допомогою індукції:

01a   10b   10b01a   10b01a10b
  a10   b01   a10b01   b01a10b01

Через 2 кроки він має правильну форму.

10b   01a   01a10b   01a10b01a
  b01   a10   b01a10   a10b01a10

Через 2 кроки він має правильну форму.

Отже, за допомогою індукції, струни завжди збігаються, коли-то об'єднані.

Haskell, 15 байт

v%w=w++w%(v++w)

Функція infix %створює нескінченну рядок, яку Haskell друкує назавжди, тому що Haskell крутий таким.

>> "1"%"0"
"010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101

Рекурсивна ідея схожа на рішення Згарба . Записуючи fфункцію %та +конкатенацію рядків, вона реалізує:

f(v,w) = w + f(w,v+w)

Нескінченний вихідний рядок починається з w, а решта його - результат для зміщених рядків Фібоначчі wта v+w.

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

Haskell, 31 байт

w#v=v++drop(length v)(v#(v++w))

Це визначає функцію інфікування, #яка займає два рядки і повертає нескінченну рядок. Використання:

> let w#v=v++drop(length v)(v#(v++w)) in "11"#"000"
"000110000001100011000000110000...

Якщо я запитую мільйонний елемент послідовності, визначеної "1" і "0", навіть онлайн-перекладач друкує результат менше ніж за секунду:

> let w#v=v++drop(length v)(v#(v++w)) in ("1"#"0") !! 1000000
'0'

Пояснення

w#v=                             -- The result of w#v is
    v++                          -- v concatenated to
                      v#(v++w)   -- the infinite word v#(v++w),
       drop(length v)            -- with the first v characters dropped.

В основному ми це знаємо w#v == v#(v++w)і починаємо w#vз vцього факту і використовуємо ці факти для визначення результату. Оскільки Haskell лінивий, це "магічно" просто працює.

Піп, 8 байт

Гей, зв’язаний з Пітом!

(fOba.b)

Безпосередньо рекурсивне визначення, запозичене з відповіді Хаскелла xnor . З пробілами додано для наочності:

(f Ob a.b)

Кожна програма в Pip - це неявна функція, яка приймає аргументи командного рядка як свої аргументи (присвоюється змінним aчерез e) і друкує її повернене значення.Oє оператором, який виводить, а потім повертає операнд, тому перше, що відбувається тут, - відображається другий аргумент (sans trailing newline).

Тепер натхненний Lisp синтаксис (f x y)у Pip - це виклик функції, еквівалентний f(x,y)мовам, схожим на C. fМінлива відноситься до поточної функції - в цьому випадку, програма верхнього рівня. Таким чином, програма рекурсивно називає себе за допомогою bіa.b в якості нових аргументів.

Я був приємно здивований, виявивши, що такий підхід досить швидкий:

dlosc@dlosc:~$ time pip -e '(fOba.b)' 1 0 2>/dev/null | head -c1000000 > /dev/null

real    0m0.217s
user    0m0.189s
sys     0m0.028s

На моїй машині Ubuntu потрібно 30 секунд, щоб програма вразила максимальну глибину рекурсії, після чого вона надрукувала десь понад мільярд цифр.

Це ітеративне рішення трохи швидше і забирає менше пам’яті ціною одного байта:

W1Sba.:Ob

CJam, 12 11 байт

llL{@_o+_}h

Це займає два слова в окремих рядках у зворотному порядку, наприклад

0
1

дає

0100101001001010010100100101001...

Пояснення

Ідея полягає в тому, щоб наростити слово наївно (запам'ятовуючи поточне слово і додаючи до нього попереднє), і поки ми це робимо, ми друкуємо все, що тільки додали (щоб не повторювати префікс, який вже був надрукований) . Щоб уникнути необхідності обробляти початкову точку окремо, ми починаємо з порожнього слова, таким чином, що W ₀ - це перше, що ми додаємо (і друкуємо).

ll    e# Read the two lines separately.
L     e# Push an empty string.
{     e# Infinite loop...
  @   e#   Pull up the previous FTW.
  _o  e#   Print it.
  +_  e#   Append it to the current FTW and duplicate it.
}h

PowerShell, 97 76 байт

param($a,$b)write-host -n $b;while(1){write-host -n $a;$e=$b+$a;$a=$b;$b=$e}

_{Редагування - Ум, виписування $e.substring($b.length)після того , як ми щойно об'єдналися $aі $bразом еквівалентно просто виписуванню$a ... дерп.}

Нічого, багатослівне. За замовчуванням PowerShell виплюне новий рядок щоразу, коли ви щось виводить. Дійсно єдиний спосіб обійти це write-host -n(з коротким -NoNewLine), і це абсолютно вбиває довжину тут.

По суті, це повторюється через послідовність, будуючи $eяк "поточний" W _{n у} міру проходження. Однак, оскільки ми хочемо побудувати нескінченне слово замість послідовності, ми використовуємо наші попередні змінні, щоб роздрукувати суфікс $a, заповнений у попередньому циклі. Потім ми встановлюємо наші змінні для наступного кругообігу і повторюємо цикл. Зверніть увагу, що це очікує, що введення буде чітко розмежоване як рядки, інакше+ оператор звикне до арифметики замість конкатенації.

Приклад:

PS C:\Tools\Scripts\golfing> .\infinite-ftw.ps1 "111" "000"
0001110000001110001110000001110000001110001110000001110001110000001110000001110001110000001110000001110001110000001110001110000001110000001110001110000001110001110000001110000001110001110000001110000001110001110000001110001110000001110000001110001110000001110000 ...

APL, 24 18

{(,/⌽⍵),⊂⍞←↑⍵}⍣≡⍞⍞

Використання формули xnor дозволило обрізати кілька символів.

                 ⍞  ⍝ Read W₋₁ as a character string.
                ⍞   ⍝ Read W₀.
{            }⍣≡    ⍝ Apply the following function repeatedly until fixpoint:
                    ⍝ It takes a pair of strings (A B),
         ⍞←↑⍵       ⍝ prints A
 (,/⌽⍵),⊂  ↑⍵       ⍝ and returns (BA A).

На нескінченної машині в нескінченне час він буде на самому ділі друкувати W _∞ тричі перший приріст у час роботи циклу, а потім два рази в результаті всього висловлювання , коли ⍣≡оператор Fixpoint нарешті , повертається.

Це не дуже швидко, але досить швидко. У APL GNU:

$ printf '%s\n' '{(,/⌽⍵),⊂⍞←↑⍵}⍣≡⍞⍞' 1 0 | apl -s | head -c 100
0100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010$
$ time printf '%s\n' '{(,/⌽⍵),⊂⍞←↑⍵}⍣≡⍞⍞' 1 0 | apl -s | head -c 1000000 >/dev/null
    0m3.37s real     0m2.29s user     0m1.98s system

Чистий баш, 58

a=$1
b=$2
printf $b
for((;;)){
printf $a
t=$b
b+=$a
a=$t
}

У мене не вистачає пам’яті до 1 хвилини, але до цього часу я маю багато цифр - через 10 секунд у мене є 100 мільйонів цифр:

$ ./ftw.sh 1 0 | head -c100
0100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010ubuntu@ubuntu:~$ 
$ { ./ftw.sh 1 0 & sleep 10 ; kill $! ; } | wc -c
102334155
$ 

Математика, 56 байт

$IterationLimit=∞;#0[$Output~WriteString~#2;#2,#<>#2]&

C, 76 (gcc)

main(c,v)char**v;{int p(n){n>2?p(n-1),p(n-2):puts(v[n]);}for(p(4);;p(c++));}

Це досить простий рекурсивний принтер, реалізований як вкладена функція (розширення GNU C не підтримується клангом), щоб уникнути необхідності проходити vнавколо. p(n)друкує W _n-2 , де W _-1 і W ₀ повинні бути вказані в v[1]і v[2]. Це спочатку вимагає p(4)друкувати W ₂ . Потім він циклічно: він закликає p(3)друкувати W ₁ , роблячи повний вихід W ₂ W ₁ , що є W ₃ . Потім він вимагає p(4)друкувати W ₂ , роблячи повний вихід ₄ Wтощо. Продуктивність трохи краща, ніж моя попередня відповідь: я бачу 1875034112 значень за хвилину.

C, 81 (стук)

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

s[],*p=s;main(c,v)char**v;{for(++v;;)for(puts(v[*++p=*++p!=1]);*p+1==*--p;++*p);}

Це всі види невизначеної поведінки, в основному для розваги. Він працює з клангом 3.6.2 в Linux і з кланг 3.5.2 на Cygwin для тестових випадків у питанні, з спеціальними параметрами командного рядка або без них. Не вмикається, коли ввімкнено оптимізацію.

Він не працює з іншими компіляторами.

Ви можете приймати слова в будь-якому порядку; як два масиви, масив масивів, два рядки, масив рядків або один рядок з роздільником, який ви обрали.

Я приймаю слова як аргументи командного рядка в рядковому форматі.

Ви можете друкувати цифри нескінченного слова або без роздільника, або з послідовним роздільником між кожною парою сусідніх цифр.

Я використовую новий рядок як послідовний роздільник.

Припустимо, що у коду ніколи не залишиться пам’яті та його типи даних не переповнюються.

Зокрема, це означає, що будь-який вихід до STDOUT або STDERR, який є результатом збоїв, буде ігнорований.

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

Якщо я запускаю ваш код на моїй машині (Intel i7-3770, 16 GiB оперативної пам’яті, Fedora 21) протягом однієї хвилини і передаю його вихід wc -c, він повинен надрукувати щонайменше мільйон цифр W _∞ для (W _-1 , W ₀ ) = (1, 0) .

{ ./program 1 0 | tr -d '\n' & sleep 60; kill $!; } | wc -cТестуючи за допомогою , я отримую 1816784896 цифр за одну хвилину на моїй машині, коли програма була складена -O3, і 1596678144, коли вона складена з оптимізаціями, включеними.

Ungolfed, без UB, з поясненням:

#include <stdio.h>

// Instead of starting with -1 and 0, start with 0 and 1. I will use lowercase w for that,
// so that wx = W(x-1).

// Declare a variable length array of numbers indicating what has been printed.
// The length is indicated through a pointer just past the end of the values.
// The first element of the array is a special marker.
// [0 3 1] means that w3 w1 has been printed.
// The array is initialised to [0] meaning nothing has been printed yet.
int stack[99999];
int *ptr = stack + 1;

int main(int argc, char *argv[]) {
  ++argv; // Let argv[0] and argv[1] refer to w0 and w1.
  for(;;) {
    // Determine the word to print next, either 0 or 1.
    // If we just printed 1 that wasn't the end of a different word, we need to print 0 now.
    // Otherwise, we need to print 1.
    int word = ptr[-1] != 1;

    // Print the word, and mark the word as printed.
    puts(argv[word]);
    *ptr++ = word;

    // If we just printed w(x) w(x-1) for any x, we've printed w(x+1).
    while (ptr[-1] + 1 == ptr[-2]) {
      --ptr;
      ++ptr[-1];
    }
  }
}

Javascript (53 байти)

(a,c)=>{for(;;process.stdout.write(a))b=a,a=c,c=b+a;}

Введення має бути рядок, а не число ( '0'і не просто 0).

Перл 5, 45 55 49 байт

44 байти, плюс 1 для -Eзамість-e

sub{$i=1;{say$_[++$i]=$_[$i].$_[$i-1];redo}}

Використовуйте як напр

perl -E'sub{$i=1;{say$_[++$i]=$_[$i].$_[$i-1];redo}}->(1,0)'

Це друкує послідовні наближення до W _∞, і таким чином, якщо ви чекаєте досить довго, друкується на останньому рядку виводу, W _∞ на будь-яку потрібну довжину, як потрібно. Цифри слова сполучені без роздільника.

Оскільки я перебуваю в Windows, я перевірив його на вимогу "принаймні один мільйон цифр W _∞ ", запустивши його з виводом, переспрямованим у файл, та знищивши його приблизно через 59 секунд, а потім запустив GnuWin32 wc -L, який надрукував 701408733.

Оновлення:

У коментарі до цієї відповіді ОП уточнила (і, мабуть, я мав би зрозуміти все-таки), що додатковий вихід, що передує W _∞, дискваліфікує вище. Тож натомість ось 55-байтове рішення, яке друкує лише W _∞ :

sub{print$_[0];{print$_[1];unshift@_,$_[0].$_[1];redo}}

Використовується так само, але з аргументами в зворотному порядку і не вимагає -E:

perl -e'sub{print$_[0];{print$_[1];unshift@_,$_[0].$_[1];redo}}->(0,1)'

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

Подальше оновлення:

Денніс поголив п'ять байтів, використовуючи -a(таким чином, читаючи, <>щоб видалити sub) і перепризначив параметр, переданий printв кінціredo блоку:

З -aneі читання з <>(обидва входи в одному рядку, розділені пробілом, у зворотному порядку); 48 + 2 байти:

$_=$F[0];{print;unshift@F,$F[0].($_=$F[1]);redo}

І, виходячи з цього, я поголив ще один байт (такий же, як вище, але тепер введення в правильному порядку); 47 + 2 байти:

$_=$F[1];{print;push@F,$F[-1].($_=$F[-2]);redo}

REXX , 48

arg a b
do forever
b=a||b
say b
a=b||a
say a
end

ftw.rex
exec ftw.rex 0 1

Наразі не можна перевірити продуктивність, тому що я використовував онлайн-компілятор для його написання. "Вічно" можна замінити будь-яким числом, де як друковані номери ftw (число + 2).

Я також написав невелике (безладне) рішення у Prolog. Не зрозумів, як перевірити працездатність з цим, але все одно його, мабуть, жорстоким.

f(A,B,C):-atom_concat(B,A,D),(C=D;f(B,D,C)).

:- C='0';C='1';(f(1,0,C)).

Python 2, 67 байт

a,b=input()
print'\n'.join(b+a)
while 1:a,b=b,b+a;print'\n'.join(a)

Приймає введення у вигляді пари рядків "1","0", розділених комами:, наприклад, у запитанні.

Немає онлайн-перекладача, оскільки нескінченні петлі погані. Буферний вихід змусив мене набрати багато байтів. :( Дякую Деннісу, що вказав, що 1 цифра на рядок є дійсною.

Час роботи моєї (значно слабкішої) машини:

$ time python golf.py <<< '"1","0"' 2>/dev/null | head -c2000000 > /dev/null

real    0m1.348s
user    0m0.031s
sys     0m0.108s

Діялог АПЛ, 9

{⍵∇⍺,⍞←⍵}

Цей використовується ∇для визначення рекурсивної функції. Це прямий переклад цієї відповіді на Python 3 xnor . Він має W ₀ праворуч, а W _-1 як його лівий аргумент, обидва мають бути векторами символів.

Мінколанг 0,11 , 62 байти

(od" "=,6&xI0G2@dO$I)I1-0G($d2[I2:g]Xx0c2*1c-0g0g-d[icO]0G0G1)

Спробуйте тут. Очікує введення в порядку W ₀ , W _-1 з пробілом між ними.

Пояснення

(                             Open while loop (for input-reading)
 od                           Read in character from input and duplicate
   " "=,                      0 if equal to " ", 1 otherwise
        6&                    Jump 6 characters if this is non-zero
          xI0G2@              Dump, push length of stack, move to front, and jump next two
                dO            Duplicate and output as character if 1
                  $I)         Close while loop when input is empty
                     I1-0G    Push length of stack - 1 and move it to the front

Мета-пояснення наступного полягає в тому, що на даний момент часу у нас є два числа, за якими слідує рядок "0" s та "1" s без розділення. Якщо довжини W ₀ і W _-1 дорівнюють aі b, відповідно, два числа на передній частині стека є <a+b>і <a>в такому порядку. Слово, утворене сполученням W _{i + 1} і W _i , тобто W _{i + 1} + W _i , дорівнює 2 * W _{i + 1} - W _i . Отже наступний код дублює стек (2 * W _{i + 1} ), спливає зверху<a> елементів (- W) _i ), а потім замінює <a+b>і<a> їх правонаступників, <a+2b>і <b>.

(                                       Open while loop (for calculation and output)
 $d                                     Duplicate the whole stack
   2[I2:g]                              Pull <a+b> and <a> from the middle of the stack
          Xx                            Dump the top <a> elements (and <a+b>)
            0c2*1c-                     Get <a+b> and <a>, then calculate
                                        2*<a+b> - <a> = <a+2b> = <a+b> + <b>
                   0g0g-                Get <a+b> and <a>, then subtract
                        d[icO]          Output as character the first <b> elements
                              0G0G      Move both to front
                                  1)    Infinite loop (basically, "while 1:")

Пітон 3, 32

def f(a,b):print(end=b);f(b,a+b)

Та сама рекурсивна ідея, як і моя відповідь Haskell , за винятком того, що префікс друкується, оскільки Python не може обробляти нескінченні рядки.

Використовували трюк від Sp3000 для друку без пробілів, додавши рядок як endаргумент у Python 3

Perl, 32 байти

#!perl -pa
$#F=3}for(@F){push@F,$F[-1].$_

Підрахувавши шебанг як два, вхід береться від stdin, простір розділений як W ₀ , W _-1 . Вихід за 1 Мб разів на ~ 15 мс, більшість з яких можна віднести до запуску інтерпретатора.

Використання зразка

$ echo 0 1 | perl inf-ftw.pl
0100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001...

$ echo 110 101 | perl inf-ftw.pl
1101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101...

Пролог, 69 байт

q(A,B):-atom_concat(B,A,S),write(A),q(B,S).
p(A,B):-write(B),q(A,B).

Приклад введення: p ('1', '0')

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