Escriba un programa con longitud n que genere otro programa cuya longitud sea el siguiente número de Fibonacci después de n. El nuevo programa debe hacer lo mismo: generar otro programa cuya longitud sea el siguiente número de Fibonacci, etc.
n en sí mismo (la longitud del programa original) no tiene que ser un número de Fibonacci, aunque sería bueno si lo fuera.

El código más corto gana.

Sin recursos externos, solo ASCII, se requiere compilador / intérprete gratuito.
Si su salida termina en una nueva línea, también se cuenta.

CJam, 26 23

Acabo de probar tu idioma.

7{9\@5mq)2/*')*\"_~"}_~

9 es (22*0.618 + 0.5 - 1)/1.618 + 1.

Calcula su propia longitud en *1.618lugar de sumar repetidamente los dos números. En la primera versión, llenará la salida antes de me {gusta 1))))))))), que cuenta esos caracteres. Di el resultado n. La longitud total es n+22, y la nueva longitud anterior {debe ser (n+22)*1.618-22, redondeada. Disminuya en uno para contar el número de )'s. Entonces será aproximadamente igual a (n+8)*1.618.

Versión antigua:

-3{1\@5mq)2/*E+')*\"_~"}_~

El número 14 es 24*0.618 + 0.5 - 1.

Python 2, 160 bytes

s='s=%s;c=s;l=len(s%%c)+4;a,b=1,1\nwhile b<l:a,b=b,a+b\nc+="1"*(b-l-1);print s%%`c`;a=1'
c=s
l=len(s%c)+4
a,b=1,1
while b<l:a,b=b,a+b
c+="1"*(b-l-1)
print s%`c`

Este es un verdadero cuasi-quine; no lee su propia fuente, pero la genera. Primera salida (tiene nueva línea final):

s='s=%s;c=s;l=len(s%%c)+4;a,b=1,1\nwhile b<l:a,b=b,a+b\nc+="1"*(b-l-1);print s%%`c`;a=111111111111111111111111111111111111111111111111111111111111111111111';c=s;l=len(s%c)+4;a,b=1,1
while b<l:a,b=b,a+b
c+="1"*(b-l-1);print s%`c`;a=1

Segundo:

s='s=%s;c=s;l=len(s%%c)+4;a,b=1,1\nwhile b<l:a,b=b,a+b\nc+="1"*(b-l-1);print s%%`c`;a=1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111';c=s;l=len(s%c)+4;a,b=1,1
while b<l:a,b=b,a+b
c+="1"*(b-l-1);print s%`c`;a=111111111111111111111111111111111111111111111111111111111111111111111

_{Editar: ¡Vaya! Olvidé cambiar la cadena cuando cambié de ;s a 1s, por lo que la segunda salida estaba generando puntos y comas adicionales (que Python no admite). Fijo}

CJam, 41 31 bytes

{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~

Pruébalo en línea.

Salida

$ cjam <(echo '{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~'); echo
{1$+S@]_1=4+1$`,-S*"2$~"}34 21 2$~
$ cjam <(echo '{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~') | wc -c
34
$ cjam <(cjam <(echo '{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~')); echo
{1$+S@]_1=4+1$`,-S*"2$~"}55 34                      2$~
$ cjam <(cjam <(echo '{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~')) | wc -c
55
$ cjam (cjam <(cjam <(echo '{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~'))); echo
bash: syntax error near unexpected token `cjam'
$ cjam <(cjam <(cjam <(echo '{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~'))); echo
{1$+S@]_1=4+1$`,-S*"2$~"}89 55                                                        2$~
$ cjam <(cjam <(cjam <(echo '{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~'))) | wc -c
89

Cómo funciona

{       "                                                   {…} 21 13                     ";
  1$+   " Duplicate the higher number and add.              {…} 21 34                     ";
  S@    " Push a space and rotate the lower number on top.  {…} 34 ' ' 21                 ";
  ]     " Wrap the stack into an array.                     [ {…} 34 ' ' 21 ]             ";
  _1=   " Push the second element of the array.             [ {…} 34 ' ' 21 ] 34          ";
  4+    " Add 4 to it.                                      [ {…} 34 ' ' 21 ] 38          ";
  1$`,  " Push the length of the stringified array.         [ {…} 34 ' ' 21 ] 38 37       ";
  -S*   " Subtract and push that many spaces.               [ {…} 34 ' ' 21 ] ' '         ";
  "2$~" " Push the string '2$~'.                            [ {…} 34 ' ' 21 ] ' ' '2$~'   ";
}       "                                                   {…}                           ";

21D     " Push 21 and 13.                                   {…} 21 13                     ";
2$~     " Copy the code block an evaluate.                  [ {…} 34 ' ' 21 ] ' ' '2$~'   ";

Python - 89

g="%(s,b,a+b);print o.ljust(b-1)";s,a,b="s,a,b=%r,%i,%i;o=s%"+g,89,144;exec("o=s"+g)#####

Mi cuenta perfecta de personajes se ha ido . ; _; Gracias a TheRare por señalar lo de la nueva línea y a Quincunx por sugerir que use Python 2, eliminando 2 caracteres.

EDITAR : ahora solo usa más #s en lugar de 1s; 12 caracteres más cortos.

EDIT 2 : 94 caracteres! Eliminó algunas repeticiones. >: 3

EDIT 3 : alternativa de repr más corta para Python 2.

EDIT 4 : La salida es un carácter más corto ahora.

EDITAR 5 : El uso de %racortarlo fue tomado de una respuesta a otra pregunta de @primo.

EDITAR 6 : más corto. :RE

Aquí hay una versión de Python 3:

g="%(s,b,a+b);print(o.ljust(b-1))";s,a,b="s,a,b=%r,%i,%i;o=s%"+g,89,144;exec("o=s"+g)####

Esta respuesta es similar a la de @Quincunx.

JavaScript, 94

(function q(w,e){return ('('+q+')('+e+','+(s=w+e)+')'+Array(s).join('/')).substr(0,s)})(55,89)

Basado en un conocido JavaScript Quine , esto devuelve casi la misma función, solo seguida de una cantidad de barras, de modo que suma 144, que es el próximo número de Fibonacci después de N. Y así sucesivamente ...

N no es un número de Fibonacci, pero solo fue "bueno tenerlo".

Mathematica

({0};
 With[{n = Ceiling[ InverseFunction[Fibonacci]@LeafCount@#0 ], l = Length[#0[[1, 1]]]},
    #0 /. {0..} -> ConstantArray[0, Fibonacci[n+1] - LeafCount[#0] + l]
 ]) &

Esta es una implementación muy sencilla (es decir, no hay ofuscación aquí). Es una función anónima que se devuelve con un poco de relleno para lograr la longitud correcta. Mathematica es homoicónico: el código y los datos están representados como expresiones de Mathematica, lo que hace que sea realmente fácil modificar / generar código sobre la marcha. Esto también significa que los recuentos de caracteres no son una medida natural de la longitud del código. El tamaño de Epxression ( "recuento de hojas" ) es. Esta versión se basa en recuentos de hojas como medida de longitud de código.

Si asignamos esta función anónima a una variable f(para que pueda mostrar lo que sucede de manera legible), y seguimos llamándola 1, 2, 3, ... veces, cada vez que mida la longitud del valor de retorno, esto es lo que obtenemos:

In[]:= f // LeafCount
Out[]= 42

In[]:= f[] // LeafCount
Out[]= 89

In[]:= f[][] // LeafCount
Out[]= 144

In[]:= f[][][] // LeafCount
Out[]= 233

Con respecto al requisito de intérprete gratuito: Mathematica es gratuito para Raspberry Pi. De lo contrario, este código debería ser sencillo de transferir a Mathics (código abierto) . Lo único que falta en Mathics es InverseFunction, que se puede reemplazar como aquí (pero soy vago :).

Python 3.8 (prelanzamiento) , 78 bytes

p,c=55,89;exec(s:="print((a:=f'p,c={c},{p+c};exec(s:=%r)'%s)+'#'*(c-len(a)))")

Pruébalo en línea!