Scrivi un programma con lunghezza n che emetta un altro programma la cui lunghezza è il successivo numero di Fibonacci dopo n. Il nuovo programma deve fare la stessa cosa: produrre un altro programma la cui lunghezza è il prossimo numero di Fibonacci, ecc.
N stesso (la lunghezza del programma originale) non deve essere un numero di Fibonacci, anche se sarebbe bello se lo fosse.

Il codice più corto vince.

Nessuna risorsa esterna, solo ASCII, compilatore / interprete gratuito richiesto.
Se l'output termina con una nuova riga, viene conteggiato anche.

CJam, 26 23

Ho appena provato la tua lingua.

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

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

Calcola la propria lunghezza *1.618invece di aggiungere ripetutamente i due numeri. Nella prima versione, riempirà l'output prima del {like 1))))))))), che conta quei caratteri stessi. Dì il risultato n. La lunghezza totale è n+22e la nuova lunghezza prima {dovrebbe essere (n+22)*1.618-22arrotondata. Diminuiscilo di uno per contare il numero di ). Quindi sarà approssimativamente uguale a (n+8)*1.618.

Versione precedente:

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

Il numero 14 è 24*0.618 + 0.5 - 1.

Python 2, 160 byte

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`

Questo è un vero quasi-quine; non legge la propria fonte, ma la genera. Primo output (ha una nuova riga finale):

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

Secondo:

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

_{Modifica: Oops. Ho dimenticato di cambiare la stringa quando ho cambiato da ;s a 1s, quindi il secondo output stava producendo punti e virgola extra (che Python non supporta). Fisso}

CJam, 41 31 byte

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

Provalo online.

Produzione

$ 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

Come funziona

{       "                                                   {…} 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)#####

Il mio conteggio dei personaggi perfetto è sparito . ; _; Grazie a TheRare per aver sottolineato la cosa newline e Quincunx per aver suggerito di usare Python 2, radendo 2 caratteri.

EDIT : ora usa solo più #s invece di1 s; 12 caratteri in meno.

MODIFICA 2 : 94 caratteri! Eliminata qualche ripetizione. >: 3

EDIT 3 : alternativa repr più breve per Python 2.

MODIFICA 4 : L'output è ora un carattere più breve.

EDIT 5 : L'uso di %rper accorciarlo è stato preso da una risposta su un'altra domanda di @primo.

EDIT 6 : più breve. : D

Ecco una versione di 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)####

Questa risposta è simile a quella di @Quincunx.

JavaScript, 94

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

Basato su un noto JavaScript Quine , restituisce quasi la stessa funzione, seguita solo da una quantità di barre, in modo tale da sommare a 144 che è il prossimo numero di Fibonacci dopo N. E così via ...

N non è un numero di Fibonacci, ma era solo "bello da avere".

matematica

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

Questa è un'implementazione molto semplice (cioè nessuna offuscamento qui). È una funzione anonima che si restituisce con un po 'di imbottitura per raggiungere la lunghezza corretta. Mathematica è omoiconico: codice e dati sono entrambi rappresentati come espressioni di Mathematica, il che rende realisticamente facile modificare / generare il codice al volo. Ciò significa anche che il conteggio dei caratteri non è una misura naturale della lunghezza del codice. La dimensione dell'epressione ( "conteggio delle foglie" ) è. Questa versione si basa sul conteggio delle foglie come misura della lunghezza del codice.

Se assegniamo questa funzione anonima a una variabile f(così posso mostrare cosa succede in modo leggibile) e continuiamo a chiamarla 1, 2, 3, ... volte, ogni volta che misura la lunghezza del valore restituito, questo è ciò che noi abbiamo:

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

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

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

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

Per quanto riguarda il requisito di interprete gratuito: Mathematica è gratuito per Raspberry Pi. In caso contrario, questo codice dovrebbe essere semplice da trasferire a Mathics (open source) . L'unica cosa che manca a Mathics è InverseFunction, che può essere sostituita come qui (ma sono pigro :).

Python 3.8 (pre-release) , 78 byte

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

Provalo online!

Python 2 , 79 byte

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

Provalo online!