Écrivez un programme de longueur n qui génère un autre programme dont la longueur est le prochain numéro de Fibonacci après n. Le nouveau programme doit faire la même chose - la sortie d' un autre programme dont la longueur est le numéro suivant Fibonacci, etc.
n lui - même (la longueur du programme original) ne doit pas être un certain nombre de Fibonacci, bien que ce serait bien si elle est.

Le code le plus court gagne.

Aucune ressource externe, ASCII uniquement, compilateur / interprète gratuit requis.
Si votre sortie se termine par une nouvelle ligne, elle est également comptée.

CJam, 26 23

Je viens de faire un essai avec votre langue.

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

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

Il calcule sa propre longueur *1.618au lieu d'ajouter plusieurs fois les deux nombres. Dans la première version, il remplira la sortie avant {like 1))))))))), qui compte ces caractères eux-mêmes. Dites le résultat n. La longueur totale est n+22et la nouvelle longueur avant {doit être (n+22)*1.618-22arrondie. Diminuez-le de un pour compter le nombre de ). Il sera alors approximativement égal à (n+8)*1.618.

Ancienne version:

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

Le nombre 14 est 24*0.618 + 0.5 - 1.

Python 2, 160 octets

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`

C'est une véritable quasi-quine; il ne lit pas sa propre source, mais il la génère. Première sortie (a une nouvelle ligne de fin):

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

Seconde:

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: Oups. J'ai oublié de changer la chaîne lorsque je suis passé de ;s à 1s, donc la deuxième sortie produisait des points-virgules supplémentaires (que Python ne prend pas en charge). Fixé}

CJam, 41 31 octets

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

Essayez-le en ligne.

Production

$ 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

Comment ça fonctionne

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

Mon nombre de personnages parfait est parti . ; _; Merci à TheRare pour avoir souligné la nouveauté et Quincunx pour avoir suggéré d'utiliser Python 2, en rasant 2 caractères.

EDIT : utilise maintenant plus de #s au lieu de 1s; 12 caractères plus courts.

EDIT 2 : 94 caractères! Élimine certaines répétitions. >: 3

EDIT 3 : Alternative de représentation plus courte pour Python 2.

EDIT 4 : La sortie est un caractère plus court maintenant.

EDIT 5 : L'utilisation de%r pour le raccourcir a été tirée d'une réponse à une autre question de @primo.

EDIT 6 : Plus court. :RÉ

Voici une version 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)####

Cette réponse est similaire à celle de @Quincunx.

JavaScript, 94

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

Basé sur un Quine JavaScript bien connu , cela retourne presque la même fonction, suivie seulement par une quantité de barres obliques, de sorte qu'elle résume jusqu'à 144 qui est le prochain numéro de Fibonacci après N. Et ainsi de suite ...

N n'est pas un numéro de Fibonacci, mais c'était seulement "agréable à avoir".

Mathematica

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

Il s'agit d'une implémentation très simple (c.-à-d. Pas d'obscurcissement ici). Il s'agit d'une fonction anonyme qui se retourne avec un peu de rembourrage pour obtenir la bonne longueur. Mathematica est homoiconique: le code et les données sont tous deux représentés sous la forme d'expressions Mathematica, ce qui facilite la modification / génération de code à la volée. Cela signifie également que le nombre de caractères n'est pas une mesure naturelle de la longueur du code. La taille d'épaisseur ( "nombre de feuilles" ) est. Cette version est basée sur le nombre de feuilles comme mesure de longueur de code.

Si nous assignons cette fonction anonyme à une variable f(pour que je puisse montrer ce qui se passe de manière lisible), et continuons à l'appeler 1, 2, 3, ... fois, en mesurant chaque fois la longueur de la valeur de retour, c'est ce que on a:

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

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

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

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

Concernant l'exigence d'interprète gratuit: Mathematica est gratuit pour le Raspberry Pi. Sinon, ce code devrait être simple à porter en mathématiques (open source) . La seule chose qui manque aux mathématiques est InverseFunction, qui peut être remplacée comme ici (mais je suis paresseux :).

Python 3.8 (pré-version) , 78 octets

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

Essayez-le en ligne!

Python 2 , 79 octets

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

Essayez-le en ligne!