Schreiben Sie ein Programm mit der Länge n, das ein anderes Programm ausgibt, dessen Länge die nächste Fibonacci-Zahl nach n ist. Das neue Programm muss dasselbe tun - ein anderes Programm ausgeben, dessen Länge die nächste Fibonacci-Nummer ist usw.
n selbst (die Länge des ursprünglichen Programms) muss keine Fibonacci-Nummer sein, obwohl es schön wäre, wenn dies der Fall wäre.

Kürzester Code gewinnt.

Keine externen Ressourcen, nur ASCII, kostenloser Compiler / Interpreter erforderlich.
Wenn Ihre Ausgabe in einer neuen Zeile endet, wird sie ebenfalls gezählt.

CJam, 26 23

Ich habe es gerade mit deiner Sprache versucht.

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

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

Es berechnet seine eigene Länge, *1.618anstatt die beiden Zahlen wiederholt zu addieren. In der ersten Version wird die Ausgabe vorher {wie folgt gefüllt 1))))))))), wobei diese Zeichen selbst gezählt werden. Sagen Sie das Ergebnis n. Die Gesamtlänge ist n+22und die neue Länge {sollte (n+22)*1.618-22gerundet sein. Verringern Sie es um eins, um die Anzahl der zu zählen ). Dann wird es ungefähr gleich sein (n+8)*1.618.

Ältere Version:

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

Die Nummer 14 ist 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`

Dies ist eine wahre Quasi-Quine; Es liest keine eigene Quelle, sondern generiert sie. Erste Ausgabe (hat nachgestellte Newline):

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

Zweite:

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

_{Edit: Ups. Ich habe vergessen, die Zeichenfolge zu ändern, als ich von ;s zu 1s gewechselt habe , sodass bei der zweiten Ausgabe zusätzliche Semikolons ausgegeben wurden (die von Python nicht unterstützt werden). Fest}

CJam, 41 31 Bytes

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

Probieren Sie es online aus.

Ausgabe

$ 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

Wie es funktioniert

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

Meine perfekte Anzahl an Charakteren ist verschwunden . ; _; Vielen Dank an TheRare für den Hinweis auf die Newline-Sache und an Quincunx für den Vorschlag, Python 2 zu verwenden und 2 Zeichen abzuschneiden.

BEARBEITEN : Verwendet jetzt nur mehr #s anstelle von 1s; 12 Zeichen kürzer.

EDIT 2 : 94 Zeichen! Einige Wiederholungen beseitigt. >: 3

EDIT 3 : Kürzere Repr-Alternative für Python 2.

EDIT 4 : Die Ausgabe ist jetzt ein Zeichen kürzer.

EDIT 5 : Die Verwendung von %r, um es zu verkürzen, wurde aus einer Antwort auf eine andere Frage von @primo entnommen.

EDIT 6 : Kürzer. : D

Hier ist eine Python 3-Version:

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

Diese Antwort ähnelt der von @Quincunx.

JavaScript, 94

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

Basierend auf einer bekannten JavaScript-Quine gibt dies fast die gleiche Funktion zurück, gefolgt von Schrägstrichen, sodass sich die nächste Fibonacci-Zahl nach N auf 144 summiert. Und so weiter ...

N ist keine Fibonacci-Zahl, aber es war nur "schön zu haben".

Mathematica

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

Dies ist eine sehr einfache Implementierung (dh hier keine Verschleierung). Es ist eine anonyme Funktion, die sich selbst mit ein wenig Abstand zurückgibt, um die richtige Länge zu erreichen. Mathematica ist homoikonisch: Code und Daten werden beide als Mathematica-Ausdrücke dargestellt, wodurch es relativ einfach ist, Code im laufenden Betrieb zu ändern / zu generieren. Dies bedeutet auch, dass die Anzahl der Zeichen kein natürliches Maß für die Codelänge ist. Die Epxressionsgröße ( " Blattzahl " ) beträgt. Diese Version basiert auf Blattzählungen als Maß für die Codelänge.

Wenn wir diese anonyme Funktion einer Variablen zuweisen f(damit ich auf lesbare Weise zeigen kann, was passiert) und sie jedes Mal 1, 2, 3, ... Mal aufrufen, wenn wir die Länge des Rückgabewerts messen, ist dies das, was wir bekommen:

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

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

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

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

Zum kostenlosen Dolmetscher: Mathematica ist für den Raspberry Pi kostenlos. Andernfalls sollte sich dieser Code problemlos nach Mathics portieren lassen (Open Source) . Das einzige, was in der Mathematik fehlt, ist InverseFunction, dass es wie hier ersetzt werden kann (aber ich bin faul :).