La palabra infinita de Fibonacci es una secuencia específica e infinita de dígitos binarios, que se calculan mediante la concatenación repetida de palabras binarias finitas.

Definamos que una secuencia de palabras de tipo Fibonacci (o FTW secuencia ) es cualquier secuencia de ⟨W _n ⟩ que se forma como sigue.

• Comience con dos matrices arbitrarias de dígitos binarios. Llamemos a estas matrices W _-1 y W ₀ .

• Para cada n> 0 , deje W _n ≔ W _n-1 ∥ W _n-2 , donde ∥ denota concatenación.

Una consecuencia de la definición recursiva es que W _n es siempre un prefijo de W _{n + 1} y, por lo tanto, de todo W _k tal que k> n . En un sentido, esto significa que la secuencia de ⟨W _n ⟩ converge a una palabra infinito.

Formalmente, dejemos que W _∞ sea ​​la única matriz infinita tal que W _n sea ​​un prefijo de W _∞ para todos n ≥ 0 .

Llamaremos a cualquier palabra infinita formada por el proceso anterior un FTW infinito .

Tarea

Escriba un programa o función que acepte dos palabras binarias W _-1 y W ₀ como entrada e imprima W _∞ , respetando las siguientes reglas adicionales:

• Puede aceptar las palabras en cualquier orden; como dos matrices, una matriz de matrices, dos cadenas, una matriz de cadenas o una sola cadena con un delimitador de su elección.

• Puede imprimir los dígitos de la palabra infinita sin un delimitador o con un delimitador consistente entre cada par de dígitos adyacentes.

• Para todos los propósitos, suponga que su código nunca se quedará sin memoria y que sus tipos de datos no se desbordan.

  En particular, esto significa que cualquier salida a STDOUT o STDERR que sea el resultado de un bloqueo se ignorará.

• Si ejecuto su código en mi máquina (Intel i7-3770, 16 GiB RAM, Fedora 21) durante un minuto y canalizo su salida wc -c, debe imprimir al menos un millón de dígitos de W _∞ para (W _-1 , W ₀ ) = (1, 0) .

• Aplican reglas estándar de código de golf .

Ejemplo

Deje W _-1 = 1 y W ₀ = 0 .

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

Esta es la palabra infinita de Fibonacci.

Casos de prueba

Todos los casos de prueba contienen los primeros 1,000 dígitos del FTW infinito.

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 bytes

u,peGsGQ

Entrada en el formulario "W-1", "W0".

Prueba de finalización:

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

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

Prueba de corrección:

Aquí está la serie como generada internamente. Está impreso en concatenación por el programa.

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

Compare con lo siguiente, impreso en concatenación, que es simplemente la cadena agregada a la cadena anterior en cada paso:

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

Queremos demostrar que son equivalentes.

Claramente, son los mismos en los primeros pasos. Vamos a compararlos después de un momento:

010
  010

10010
  01001

01010010
  01001010

1001001010010
  0100101001001

Vemos que los pares de cadenas son alternativamente de las formas:

01a 10b
a10 b01

Donde ayb son secuencias arbitrarias en 0s y 1s. Continuemos la secuencia por un momento, para demostrar que continúa para siempre por inducción:

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

2 pasos después, es de la forma correcta.

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

2 pasos después, es de la forma correcta.

Entonces, por inducción, las cadenas siempre coinciden una vez concatenadas.

Haskell, 15 bytes

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

La función infija %produce una cadena infinita, que Haskell imprime para siempre porque Haskell es genial así.

>> "1"%"0"
"010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101

La idea recursiva es similar a la solución de Zgarb . Al escribir fpara la función %y +para la concatenación de cadenas, implementa:

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

La cadena de salida infinita comienza con w, y el resto de la misma es el resultado de las cadenas con desplazamiento de Fibonacci wy v+w.

Esto no tiene problemas para generar un millón de caracteres en un minuto.

Haskell, 31 bytes

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

Esto define una función infija #que toma dos cadenas y devuelve una cadena infinita. Uso:

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

Si consulto el elemento millonésimo de la secuencia definida por "1" y "0", incluso el intérprete en línea imprime el resultado en menos de un segundo:

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

Explicación

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.

Básicamente, sabemos eso w#v == v#(v++w)y comenzamos w#vcon v, y usamos estos hechos para definir el resultado. Como Haskell es vago, esto "mágicamente" simplemente funciona.

Pip, 8 bytes

¡Hola, atado con Pyth!

(fOba.b)

Definición recursiva directa tomada de la respuesta de Haskell de xnor . Con espacios añadidos para mayor claridad:

(f Ob a.b)

Cada programa en la pipa es una función implícita que lleva a los argumentos de línea de comandos como sus argumentos (asignados a las variables aa través e) e imprime su valor de retorno. Oes un operador que genera y luego devuelve su operando, por lo que lo primero que sucede aquí es que se muestra el segundo argumento (sin nueva línea final).

Ahora, la sintaxis inspirada (f x y)en Lisp en Pip es una llamada de función, equivalente a f(x,y)en lenguajes tipo C. La fvariable se refiere a la función actual, en este caso, el programa de nivel superior. Por lo tanto, el programa se llama recursivamente con by a.bcomo los nuevos argumentos.

Me sorprendió gratamente descubrir que este enfoque es bastante rápido:

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

En mi máquina Ubuntu, el programa tarda unos 30 segundos en alcanzar la profundidad máxima de recursión, momento en el que se ha impreso en algún lugar de más de mil millones de dígitos.

Esta solución iterativa es un poco más rápida y consume menos memoria, a costa de un byte:

W1Sba.:Ob

CJam, 12 11 bytes

llL{@_o+_}h

Esto toma las dos palabras en líneas separadas, en el orden opuesto, por ej.

0
1

da

0100101001001010010100100101001...

Explicación

La idea es construir la palabra ingenuamente (recordando la palabra actual y añadiéndole la anterior) y mientras lo hacemos, imprimimos lo que acabamos de agregar (para no repetir el prefijo que ya estaba impreso) . Para evitar tener que manejar el punto de partida por separado, partimos de una palabra vacía, de modo que W ₀ es lo primero que agregamos (e imprimimos).

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 bytes

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

_{Editar - Umm, escribir $e.substring($b.length)después de que acabamos de concatenar $ay $bjuntos es equivalente a escribir solo $a... derp.}

Wow, detallado. PowerShell, por defecto, escupirá una nueva línea cada vez que envíe algo. Realmente, la única forma de evitar eso es con write-host -n(abreviatura de -NoNewLine), y eso mata absolutamente la longitud aquí.

En esencia, esta itera a través de la secuencia, la construcción $ecomo el "actual" W _n medida que avanzamos. Sin embargo, dado que queremos construir la palabra infinita en lugar de la secuencia, aprovechamos nuestras variables anteriores para imprimir el sufijo $aque se rellenó en nuestro bucle anterior. Luego configuramos nuestras variables para la próxima ronda y repetimos el ciclo. Tenga en cuenta que esto espera que la entrada se delimite explícitamente como cadenas, de lo contrario, el +operador se utiliza para la aritmética en lugar de la concatenación.

Ejemplo:

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

APL, 24 18

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

El uso de la formulación de xnor permitió eliminar algunos caracteres.

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

En una máquina infinita en tiempo infinito, en realidad imprimiría W _∞ tres veces, primero de forma incremental mientras se ejecuta el ciclo, y luego dos veces como resultado de la expresión completa cuando el ⍣≡operador del punto fijo finalmente regresa.

No es muy rápido pero lo suficientemente rápido. En 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

Puro golpe, 58

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

Me quedo sin memoria antes de 1 minuto, pero tengo muchos dígitos para entonces; después de 10 segundos tengo 100 millones de dígitos:

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

Mathematica, 56 bytes

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

Esta es una impresora recursiva bastante sencilla, implementada como una función anidada (una extensión GNU C no compatible con clang) para evitar tener que pasar v. p(n)imprime W _n-2 , donde W _-1 y W ₀ deben proporcionarse en v[1]y v[2]. Inicialmente, esto llama p(4)a imprimir W ₂ . Luego realiza un bucle: llama p(3)a imprimir W ₁ , haciendo que la salida completa sea W ₂ W ₁ , que es W ₃ . Luego llama p(4)para imprimir W ₂ , haciendo que la salida completa sea W₄ , etc. El rendimiento es ligeramente mejor que mi respuesta anterior: estoy viendo 1875034112 valores en un minuto.

C, 81 (sonido metálico)

Este es un enfoque completamente diferente al anterior que creo que vale la pena seguir, a pesar de que es peor.

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

Esto tiene todo tipo de comportamiento indefinido, principalmente por diversión. Funciona con clang 3.6.2 en Linux y con clang 3.5.2 en Cygwin para los casos de prueba en la pregunta, con o sin opciones especiales de línea de comandos. No se rompe cuando las optimizaciones están habilitadas.

No funciona con otros compiladores.

Puede aceptar las palabras en cualquier orden; como dos matrices, una matriz de matrices, dos cadenas, una matriz de cadenas o una sola cadena con un delimitador de su elección.

Acepto las palabras como argumentos de línea de comandos en formato de cadena.

Puede imprimir los dígitos de la palabra infinita sin un delimitador o con un delimitador consistente entre cada par de dígitos adyacentes.

Yo uso nueva línea como delimitador consistente.

Para todos los propósitos, suponga que su código nunca se quedará sin memoria y que sus tipos de datos no se desbordan.

En particular, esto significa que cualquier salida a STDOUT o STDERR que sea el resultado de un bloqueo se ignorará.

Accedo sfuera de los límites. Esto seguramente debe terminar con una falla de seguridad o una infracción de acceso en algún momento. ssucede que se coloca al final del segmento de datos, por lo que no debería bloquear otras variables y dar una salida incorrecta antes de ese segfault. Ojalá.

Si ejecuto su código en mi máquina (Intel i7-3770, 16 GiB RAM, Fedora 21) durante un minuto y canalizo su salida wc -c, debe imprimir al menos un millón de dígitos de W _∞ para (W _-1 , W ₀ ) = (1, 0) .

Al realizar la prueba { ./program 1 0 | tr -d '\n' & sleep 60; kill $!; } | wc -c, obtengo 1816784896 dígitos en un minuto en mi máquina cuando se compiló el programa -O3y 1596678144 cuando se compiló con optimizaciones marcadas.

Sin golf, sin UB, con explicación:

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

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

La entrada debe ser una cadena y no un número ( '0'y no solo 0).

Perl 5, 45 55 49 bytes

44 bytes, más 1 para -E lugar de-e

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

Usar como p. Ej.

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

Esto imprime aproximaciones sucesivas a W _∞ y, por lo tanto, si espera lo suficiente, imprime, en su última línea de salida, W _∞ a cualquier longitud deseada, según sea necesario. Los dígitos de la palabra se concatenan sin un delimitador.

Desde que estoy en Windows, lo probé para "al menos un millón de dígitos de W requisito de _∞ " ejecutándolo con la salida redirigida a un archivo y eliminándolo después de aproximadamente 59 segundos, luego ejecuté GnuWin32 wc -L, que imprimió 701408733.

Actualizar:

El OP aclaró en un comentario sobre esta respuesta (y probablemente debería haberme dado cuenta de todos modos) que la salida adicional que precede a W _qu descalifica lo anterior. Entonces, en cambio, aquí hay una solución de 55 bytes que imprime solo W _∞ :

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

Se usa de la misma manera, pero con los argumentos en orden inverso , y no requiere-E :

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

Sin duda, se puede jugar más al golf, pero no veo cómo hacerlo en este momento.

Actualización adicional:

Dennis recortó cinco bytes utilizando -a(leyendo <>para eliminar sub) y reasignando el parámetro pasado aprint final del redobloque:

Con -aney leyendo desde <>(ambas entradas en una línea, separadas por espacios, en orden inverso); 48 + 2 bytes:

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

Y, en base a eso, afeité un byte más (igual que el anterior, pero ahora las entradas están en el orden correcto); 47 + 2 bytes:

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

Actualmente no puedo probar el rendimiento porque utilicé un compilador en línea para escribirlo. El "para siempre" se puede reemplazar con cualquier número donde están los números impresos de ftw (número + 2).

También escribí una pequeña solución (desordenada) en Prolog. No descubrí cómo probar el rendimiento con este, pero de todos modos es probablemente atroz.

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 bytes

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

Acepta la entrada como un par de cadenas separadas por comas: "1","0"por ejemplo, en la pregunta.

No hay intérprete en línea porque los bucles infinitos son malos. La salida en búfer me hizo ganar muchos bytes. :( Gracias Dennis por señalar que 1 dígito por línea es válido.

Tiempo en mi máquina (significativamente más débil):

$ 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

{⍵∇⍺,⍞←⍵}

Este se usa ∇para definir una función recursiva. Es una traducción directa de esta respuesta de Python 3 de xnor . Toma W ₀ como derecho y W ₋₁ como argumento izquierdo, ambos deben ser vectores de caracteres.

Minkolang 0.11 , 62 bytes

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

Pruébalo aquí Espera entrada en el orden W ₀ , W _-1 con un espacio en el medio.

Explicación

(                             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 metaexplicación de lo siguiente es que, en este momento, tenemos dos números seguidos de una cadena de "0" y "1" sin separación. Si las longitudes de W ₀ y W _-1 son ay b, respectivamente, entonces los dos números al frente de la pila son <a+b>y <a>, en ese orden. La palabra formada al concatenar W _{i + 1} y W _i , es decir, W _{i + 1} + W _i , es igual a 2 * W _{i + 1} - W _i . Entonces, el siguiente código duplica la pila (2 * W _{i + 1} ), aparece en la parte superior<a> elementos (- W _i ), y luego reemplaza<a+b>y<a>con sus sucesores,<a+2b>y<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:")

Pitón 3, 32

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

La misma idea recursiva que mi respuesta de Haskell , excepto que el prefijo se imprime porque Python no puede manejar cadenas infinitas.

Usé un truco de Sp3000 para imprimir sin espacios al colocar la cadena como endargumento en Python 3

Perl, 32 bytes

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

Contando el shebang como dos, la entrada se toma de stdin, el espacio se separa como W ₀ , W _-1 . Salida de 1 MB veces a ~ 15 ms, la mayoría de los cuales se pueden atribuir al lanzamiento del intérprete.

Uso de muestra

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

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

Prólogo, 69 bytes

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

Entrada de ejemplo: p ('1', '0')

No he encontrado una manera de eliminar la escritura adicional.
Debería poder mejorar esto si descubro cómo hacerlo.