编写一个长度为n的程序，该程序输出另一个程序，其长度为n之后的下一个斐波那契数。新程序必须做同样的事情-输出另一个程序，该程序的长度是下一个斐波那契数，以此类推
。n本身（原始程序的长度）不必是斐波那契数，尽管它可以是斐波那契数。

最短的代码获胜。

无需外部资源，仅ASCII，需要免费的编译器/解释器。
如果您的输出以换行符结尾，则也将对其进行计数。

果酱，26 23

我刚刚尝试了您的语言。

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

9是(22*0.618 + 0.5 - 1)/1.618 + 1。

它计算自己的长度，*1.618而不是重复将两个数字相加。在第一个版本中，它将在{like 之前填充输出1)))))))))，后者将对这些字符本身进行计数。说出结果n。总长度为n+22，并且之前的新长度{应(n+22)*1.618-22四舍五入。将其减少1即可计算的数量)。那么它将近似等于(n+8)*1.618。

旧版本：

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

数字14是24*0.618 + 0.5 - 1。

Python 2，160个字节

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`

这是一个真正的准奎因。它不会读取自己的来源，但会生成它。第一个输出（末尾有换行符）：

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

第二：

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

_{编辑：糟糕。当我从;s 更改为s 时，忘记了更改字符串1，因此第二个输出是输出额外的分号（Python不支持）。固定}

CJam，41 31个字节

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

在线尝试。

输出量

$ 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

怎么运行的

{       "                                                   {…} 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$~'   ";

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

我完美的角色数不见了。; _; 感谢TheRare指出换行符，并感谢Quincunx建议我使用Python 2，减少2个字符。

编辑：现在只使用more #而不是1s；缩短12个字符。

编辑2：94个字符！消除了一些重复。>：3

编辑3：Python 2的简短repr替代方案。

编辑4：现在输出是一个短字符。

编辑5：使用%r它来缩短它来自@primo对另一个问题的回答。

编辑6：较短。：D

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

这个答案类似于@Quincunx的答案。

JavaScript，94

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

基于众所周知的JavaScript Quine，此函数返回几乎相同的函数，仅后跟斜杠数量，以至于它的总和为144，这是N之后的下一个斐波那契数。等等。

N不是斐波那契数，但仅是“ nice to have”。

Mathematica

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

这是一个非常简单的实现（即，此处没有混淆）。这是一个匿名函数，返回的自身带有一些填充以实现正确的长度。Mathematica是谐音的：代码和数据都以Mathematica表达式表示，这使得在旅途中实时修改/生成代码非常容易。这也意味着字符计数不是代码长度的自然度量。上衣尺寸（“叶数”）为。此版本基于叶计数作为代码长度度量。

如果我们将此匿名函数分配给一个变量f（这样我就可以以一种可读的方式显示发生的事情），并且每次调用返回值的长度时都将其分别调用1、2、3，...次，这就是我们得到：

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

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

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

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

关于免费的口译员要求：Raspberry Pi免费提供Mathematica。否则，此代码应易于移植到Mathics（开源）。Mathics唯一缺少的是InverseFunction，可以在此处将其替换（但是我很懒：）。

Python 3.8（预发布），78字节

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

在线尝试！

Python 2，79字节

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

在线尝试！