La parola infinita di Fibonacci è una sequenza infinita specifica di cifre binarie, che sono calcolate dalla concatenazione ripetuta di parole binarie finite.

Definiamo che una sequenza di parole Fibonacci tipo (o FTW sequenza ) è qualsiasi sequenza ⟨W _n ⟩ che si forma come segue.

• Inizia con due matrici arbitrarie di cifre binarie. Chiamiamo questi array W _-1 e W ₀ .

• Per ogni n> 0 , lascia W _n ≔ W _n-1 ∥ W _n-2 , dove ∥ indica concatenazione.

Una conseguenza della definizione ricorsiva è che W _n è sempre un prefisso di W _{n + 1} e, quindi, di tutto W _k tale che k> n . In un certo senso, questi mezzi la sequenza ⟨W _n ⟩ converge ad una parola infinita.

Formalmente, sia W _∞ l'unico array infinito tale che W _n sia un prefisso di W _∞ per tutti n ≥ 0 .

Chiameremo qualsiasi parola infinita formata dal processo sopra un FTW infinito .

Compito

Scrivi un programma o una funzione che accetta due parole binarie W _-1 e W ₀ come input e stampa W _∞ , rispettando le seguenti regole aggiuntive:

• Puoi accettare le parole in qualsiasi ordine; come due array, un array di array, due stringhe, un array di stringhe o una stringa singola con un delimitatore a scelta.

• È possibile stampare le cifre della parola infinita o senza un delimitatore o con un delimitatore coerente tra ciascuna coppia di cifre adiacenti.

• A tutti gli effetti, supponi che il tuo codice non esaurirà mai la memoria e che i suoi tipi di dati non traboccino.

  In particolare, ciò significa che qualsiasi output su STDOUT o STDERR che è il risultato di un arresto anomalo verrà ignorato.

• Se eseguo il codice sulla mia macchina (Intel i7-3770, 16 GiB RAM, Fedora 21) per un minuto e installo il suo output su wc -c, deve stampare almeno un milione di cifre di W _∞ per (W _-1 , W ₀ ) = (1, 0) .

• Si applicano le regole standard del code-golf .

Esempio

Sia W _-1 = 1 e W ₀ = 0 .

Quindi W ₁ = 01 , W ₂ = 010 , W ₃ = 01001 , W ₄ = 01001010 … e W _∞ = 010010100100101001010… .

Questa è la parola infinita di Fibonacci.

Casi test

Tutti i casi di test contengono le prime 1.000 cifre dell'infinito 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 byte

u,peGsGQ

Inserisci nel modulo "W-1", "W0".

Prova di completamento:

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

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

Prova di correttezza:

Ecco la serie generata internamente. È stampato in concatenazione dal programma.

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

Confronta i seguenti, stampati in concatenazione, che è semplicemente la stringa aggiunta alla stringa precedente in ogni passaggio:

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

Vogliamo dimostrare che sono equivalenti.

Chiaramente, sono gli stessi attraverso i primi passi. Confrontiamoli dopo un po ':

010
  010

10010
  01001

01010010
  01001010

1001001010010
  0100101001001

Vediamo che le coppie di stringhe sono alternativamente delle forme:

01a 10b
a10 b01

Dove aeb sono sequenze arbitrarie su 0 e 1 secondi. Continuiamo la sequenza per un po ', per dimostrare che continua per sempre per induzione:

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

2 passi dopo, è nella forma corretta.

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

2 passi dopo, è nella forma corretta.

Quindi per induzione, le stringhe corrispondono sempre una volta concatenate.

Haskell, 15 byte

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

La funzione infix %produce una stringa infinita, che Haskell stampa per sempre perché Haskell è così bello.

>> "1"%"0"
"010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101

L'idea ricorsiva è simile alla soluzione di Zgarb . Scrivendo fper la funzione %e +per la concatenazione di stringhe, implementa:

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

La stringa di output infinita inizia con w, e il resto è il risultato per le stringhe con spostamento di Fibonacci we v+w.

Questo non ha problemi a generare un milione di caratteri in un minuto.

Haskell, 31 byte

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

Questo definisce una funzione infix #che accetta due stringhe e restituisce una stringa infinita. Uso:

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

Se interrogo il milionesimo elemento della sequenza definita da "1" e "0", anche l' interprete online stampa il risultato in meno di un secondo:

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

Spiegazione

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.

Fondamentalmente, lo sappiamo w#v == v#(v++w)e w#vcominciamo ve usiamo questi fatti per definire il risultato. Dato che Haskell è pigro, questo "magicamente" funziona e basta.

Pip, 8 byte

Ehi, legato con Pyth!

(fOba.b)

Definizione ricorsiva semplice presa in prestito dalla risposta Haskell di xnor . Con spazi aggiunti per maggiore chiarezza:

(f Ob a.b)

Ogni programma in Pip è una funzione implicita che prende gli argomenti della riga di comando come argomenti (assegnati alle variabili aattraverso e) e stampa il suo valore di ritorno. Oè un operatore che emette e quindi restituisce il suo operando, quindi la prima cosa che accade qui è il secondo argomento visualizzato (senza fine newline).

Ora, la sintassi ispirata a Lisp (f x y)in Pip è una chiamata di funzione, equivalente a f(x,y)nei linguaggi di tipo C. La fvariabile si riferisce alla funzione corrente, in questo caso il programma di livello superiore. Pertanto, il programma si chiama ricorsivamente con be a.bcome nuovi argomenti.

Sono stato piacevolmente sorpreso di scoprire che questo approccio è molto veloce:

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

Sono necessari circa 30 secondi sulla mia macchina Ubuntu affinché il programma raggiunga la massima profondità di ricorsione, a quel punto ha stampato da qualche parte oltre un miliardo di cifre.

Questa soluzione iterativa è leggermente più veloce e consuma meno memoria, al costo di un byte:

W1Sba.:Ob

CJam, 12 11 byte

llL{@_o+_}h

Questo porta le due parole su righe separate, nell'ordine opposto, ad es

0
1

dà

0100101001001010010100100101001...

Spiegazione

L'idea è quella di costruire la parola in modo ingenuo (ricordando la parola corrente e aggiungendola alla precedente) e mentre lo stiamo facendo, stampiamo tutto ciò che abbiamo appena aggiunto (per non ripetere il prefisso che era già stato stampato) . Per evitare di dover gestire il punto di partenza separatamente, partiamo da una parola vuota, in modo che W ₀ sia la prima cosa che aggiungiamo (e stampiamo).

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 byte

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

_{Modifica - Umm, scrivere $e.substring($b.length)dopo che ci siamo appena concatenati $ae $binsieme equivale a scrivere solo $a... derp.}

Wow, prolisso. Per impostazione predefinita, PowerShell emetterà una nuova riga ogni volta che si genera qualcosa. Davvero l'unico modo per aggirare quello è con write-host -n(abbreviazione di -NoNewLine), e questo uccide assolutamente la lunghezza qui.

In sostanza, questo scorre attraverso la sequenza, costruendo $ecome "corrente" W _n mentre procediamo. Tuttavia, poiché vogliamo costruire la parola infinita anziché la sequenza, sfruttiamo le nostre variabili precedenti per stampare il suffisso $ache era popolato nel nostro ciclo precedente. Quindi impostiamo le nostre variabili per il prossimo round e ripetiamo il loop. Si noti che ciò si aspetta che l'input sia delimitato esplicitamente come stringhe, altrimenti l' +operatore viene utilizzato per l'aritmetica anziché la concatenazione.

Esempio:

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

APL, 24 18

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

L' uso della formulazione di xnor ha permesso di radere via pochi personaggi.

                 ⍞  ⍝ 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).

Su una macchina infinita in un tempo infinito verrebbe effettivamente stampato W _∞ tre volte prima incrementale durante l'esecuzione del ciclo, e quindi due volte come risultato dell'intera espressione quando l' ⍣≡operatore fixpoint infine ritorna.

Non è molto veloce ma abbastanza veloce. In GNU APL:

$ 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

Bash puro, 58

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

Ho esaurito la memoria prima di 1 minuto, ma a quel punto ho molte cifre - dopo 10 secondi ho 100 milioni di cifre:

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

Mathematica, 56 byte

$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++));}

Questa è una stampante ricorsiva abbastanza semplice, implementata come una funzione nidificata (un'estensione GNU C non supportata da clang) per evitare di dover passare v. p(n)stampa W _n-2 , dove W _-1 e W ₀ devono essere forniti in v[1]e v[2]. Inizialmente questo richiede p(4)di stampare W ₂ . Quindi esegue un ciclo: chiama p(3)per stampare W ₁ , rendendo l'output completo W ₂ W ₁ , che è W ₃ . Quindi chiama p(4)per stampare W ₂ , rendendo l'output W completo₄ , ecc. Le prestazioni sono leggermente migliori della mia precedente risposta: vedo i valori di 1875034112 in un minuto.

C, 81 (clang)

Questo è un approccio completamente diverso da quanto sopra che ritengo valga la pena tenere il passo, anche se ha un punteggio peggiore.

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

Questo ha tutti i tipi di comportamento indefinito, principalmente per divertimento. Funziona con clang 3.6.2 su Linux e con clang 3.5.2 su Cygwin per i casi di test nella domanda, con o senza opzioni speciali della riga di comando. Non si interrompe quando le ottimizzazioni sono abilitate.

Non funziona con altri compilatori.

Puoi accettare le parole in qualsiasi ordine; come due array, un array di array, due stringhe, un array di stringhe o una stringa singola con un delimitatore a scelta.

Accetto le parole come argomenti della riga di comando in formato stringa.

È possibile stampare le cifre della parola infinita o senza un delimitatore o con un delimitatore coerente tra ciascuna coppia di cifre adiacenti.

Uso newline come delimitatore coerente.

A tutti gli effetti, supponi che il tuo codice non esaurirà mai la memoria e che i suoi tipi di dati non traboccino.

In particolare, ciò significa che qualsiasi output su STDOUT o STDERR che è il risultato di un arresto anomalo verrà ignorato.

Accedo sfuori dai limiti. Questo deve sicuramente finire con una segfault o una violazione di accesso ad un certo punto. ssembra essere posizionato alla fine del segmento di dati, quindi non dovrebbe ostruire altre variabili e dare un output errato prima di quel segfault. Fiduciosamente.

Se eseguo il codice sulla mia macchina (Intel i7-3770, 16 GiB RAM, Fedora 21) per un minuto e installo il suo output su wc -c, deve stampare almeno un milione di cifre di W _∞ per (W _-1 , W ₀ ) = (1, 0) .

Provando a usare { ./program 1 0 | tr -d '\n' & sleep 60; kill $!; } | wc -c, ricevo 1816784896 cifre in un minuto sulla mia macchina quando è stato compilato il programma -O3, e 1596678144 quando è stato compilato con ottimizzazioni diabetiche.

Ungolfed, no UB, con spiegazione:

#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 byte)

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

L'input dovrebbe essere stringa e non numero ( '0'e non solo 0).

Perl 5, 45 55 49 byte

44 byte, più 1 per -Eanziché-e

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

Utilizzare come ad es

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

Questo stampa approssimazioni successive a W _∞ e quindi, se si attende abbastanza a lungo, stampa, sull'ultima riga di output, W _∞ per qualsiasi lunghezza desiderata, come richiesto. Le cifre della parola sono concatenate senza un delimitatore.

Dal momento che sono su Windows, ho provato per i "almeno un milione di cifre di W _∞ " requisito eseguendolo con uscita reindirizzato a un file e l'uccisione dopo circa 59 secondi, quindi l'esecuzione di GnuWin32 wc -L, che stampato 701.408.733.

Aggiornare:

L'OP ha chiarito in un commento su questa risposta (e probabilmente avrei dovuto capire comunque) che l'output aggiuntivo che precede W _∞ squalifica quanto sopra. Quindi invece ecco una soluzione a 55 byte che stampa solo W _∞ :

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

Usato allo stesso modo, ma con gli argomenti in ordine inverso e non richiede -E:

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

Senza dubbio può essere ulteriormente giocato a golf, ma non vedo come farlo adesso.

Ulteriore aggiornamento:

Dennis ha rasato cinque byte usando -a(quindi leggendo <>per rimuovere sub) e riassegnando il parametro passato alla printfine delredo blocco:

Con -anee lettura da <>(entrambi gli ingressi su una riga, separati da spazio, in ordine inverso); 48 + 2 byte:

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

E, in base a ciò, ho rasato un altro byte (come sopra, ma ora gli input sono nell'ordine corretto); 47 + 2 byte:

$_=$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

Al momento non riesco a testare le prestazioni perché ho usato un compilatore online per scriverlo. Il "per sempre" può essere sostituito con qualsiasi numero in cui i numeri ftw stampati sono (numero + 2).

Ho anche scritto una piccola (disordinata) soluzione in Prolog. Non ho capito come testare le prestazioni con questo, ma è probabilmente atroce comunque.

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 byte

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

Accetta input come coppia di stringhe separate da virgola:, "1","0"per esempio nella domanda.

Nessun interprete online perché i loop infiniti sono cattivi. L'output bufferizzato mi ha fatto guadagnare molti byte. :( Grazie Dennis per aver sottolineato che 1 cifra per riga è valida.

Tempismo sulla mia macchina (significativamente più debole):

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

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

Dyalog APL, 9

{⍵∇⍺,⍞←⍵}

Questo utilizza ∇per definire una funzione ricorsiva. È una traduzione diretta di questa risposta Python 3 di xnor . Prende W ₀ come a destra e W ₋₁ come argomento a sinistra, entrambi dovrebbero essere vettori di caratteri.

Minkolang 0,11 , 62 byte

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

Provalo qui. Prevede input nell'ordine W ₀ , W _-1 con uno spazio in mezzo.

Spiegazione

(                             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

La meta-spiegazione per quanto segue è che a questo punto nel tempo, abbiamo due numeri seguiti da una stringa di "0" se "1" s senza separazione. Se le lunghezze di W ₀ e W _-1 sono ae b, rispettivamente, i due numeri all'inizio della pila sono <a+b>e <a>, in quell'ordine. La parola formata concatenando W _{i + 1} e W _i , ovvero W _{i + 1} + W _i , è uguale a 2 * W _{i + 1} - W _i . Quindi il codice seguente duplica lo stack (2 * W _{i + 1} ), si apre dall'alto<a> elementi (- W _i ), quindi sostituisce<a+b>e<a>con i loro successori,<a+2b>e<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:")

Python 3, 32

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

La stessa idea ricorsiva della mia risposta Haskell , tranne per il fatto che il prefisso è stampato perché Python non è in grado di gestire stringhe infinite.

Ho usato un trucco di Sp3000 per stampare senza spazi inserendo la stringa come endargomento in Python 3

Perl, 32 byte

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

Contando lo shebang come due, l'input è preso dallo stdin, lo spazio è separato da W ₀ , W _-1 . Uscita per 1 MB di tempo a ~ 15 ms, la maggior parte dei quali può essere attribuita all'avvio dell'interprete.

Esempio di utilizzo

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

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

Prolog, 69 byte

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

Input di esempio: p ('1', '0')

Non è stato trovato un modo per rimuovere la scrittura aggiuntiva.
Dovrei essere in grado di migliorare su questo se capissi come farlo.