您将要编写一个程序，该程序将输出

1. 比原始程序大（明智的选择）
2. 运行时将打印比自己更大的另一个程序（即，新程序也是对此挑战的有效答案）

这是代码高尔夫球，所以最短的答案会获胜。

GS2（8636bd8e），0个字节

这将打印单个换行符，其中将打印两个换行符，其中将打印三个换行符，等等。

在线尝试！

H9 +：1个字符

9

那就对了。一个字符。将歌词输出到99瓶啤酒中，这是一个有效程序。所有无关数据都不算在内，但是里面有很多9。

输出的程序的输出是对99瓶啤酒的歌词59次。

这个函数给出了运行程序n次数时歌词输出的次数（如果我的计算正确的话）：

f(n) = 59n-1

GolfScript，9个字符

{.'.~'}.~

此代码输出：

{.'.~'}{.'.~'}.~

输出：

{.'.~'}{.'.~'}{.'.~'}.~

输出：

{.'.~'}{.'.~'}{.'.~'}{.'.~'}.~

等等。

我相信这是到目前为止“真正的”图灵完备的编程语言中最短的答案。

说明：

基本上，上面的原始代码是一个“ quine-layer”：它输出一个普通的quine，然后跟随其自身。

在GolfScript中，任何代码块文字（例如{foo}）（如果在堆栈上都保持原样）都是一团。因此，{.'.~'}就像其他任何代码块一样，仅输出自身即可。

所述.~的代码的末尾采取最后一个码块中的堆栈上，复制它，并执行该副本。执行时，.'.~'代码块内的代码将复制堆栈上最顶层的项目（即其自身的副本），并追加字符串.~。

在程序结束时，GolfScript解释器将对堆栈中的所有内容进行字符串化并输出，在这种情况下，堆栈由{.'.~'}比输入多的一个块以及字符串组成.~。

奖金：

在第一个]之前添加一个.（将堆栈中的所有代码块收集到一个数组中，然后再复制它们）会使它呈指数增长：

{].'.~'}.~

输出：

{].'.~'}{].'.~'}.~

输出：

{].'.~'}{].'.~'}{].'.~'}{].'.~'}.~

输出：

{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}.~

等等。

Java 7：0个字符

另存为文件Blank.java。如果将其另存为其他文件，请Blank使用适当的文件名替换任何实例。

然后，首先通过命令行在命令行中运行，然后运行。如果编译失败，请停止。

我将其列为Java 7，因为对于不同版本的Java，它的输出可能会有所不同。

前几个输出（输出到stderr）：

Error: Could not find or load main class Blank

Blank.java:1: error: class, interface, or enum expected
Error: Could not find or load main class Blank
^
Blank.java:1: error: reached end of file while parsing
Error: Could not find or load main class Blank
                                              ^
2 errors

Blank.java:1: error: class, interface, or enum expected
Blank.java:1: error: class, interface, or enum expected
^
Blank.java:1: error:  expected
Blank.java:1: error: class, interface, or enum expected
                          ^
Blank.java:1: error:  expected
Blank.java:1: error: class, interface, or enum expected
                                     ^
Blank.java:1: error: as of release 5, 'enum' is a keyword, and may not be used as an identifier
Blank.java:1: error: class, interface, or enum expected
                                          ^
  (use -source 1.4 or lower to use 'enum' as an identifier)
Blank.java:1: error: = expected
Blank.java:1: error: class, interface, or enum expected
                                               ^
Blank.java:2: error:  expected
Error: Could not find or load main class Blank
     ^
Blank.java:2: error: ';' expected
Error: Could not find or load main class Blank
      ^
Blank.java:2: error: = expected
Error: Could not find or load main class Blank
                      ^
Blank.java:2: error: = expected
Error: Could not find or load main class Blank
                                   ^
Blank.java:2: error:  expected
Error: Could not find or load main class Blank
                                              ^
Blank.java:3: error: = expected
^
^
Blank.java:3: error: ';' expected
^
 ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
     ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
          ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
           ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
            ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
          ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
           ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
            ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
              ^
Blank.java:4: error: ';' expected
Blank.java:1: error: reached end of file while parsing
                   ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
                                 ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
                                        ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
                                         ^
Blank.java:4: error: ';' expected
Blank.java:1: error: reached end of file while parsing
                                              ^
Blank.java:5: error:  expected
Error: Could not find or load main class Blank
     ^
Blank.java:5: error: ';' expected
Error: Could not find or load main class Blank
      ^
Blank.java:5: error: = expected
Error: Could not find or load main class Blank
                      ^
Blank.java:5: error: = expected
Error: Could not find or load main class Blank
                                   ^
Blank.java:5: error:  expected
Error: Could not find or load main class Blank
                                              ^
Blank.java:6: error: = expected
                                              ^
                                              ^
Blank.java:6: error: ';' expected
                                              ^
                                               ^
Blank.java:7: error: reached end of file while parsing
2 errors
        ^
30 errors

HQ9 +，HQ9 ++等，2个字符

QQ

这是输出：

QQQQ

红宝石27

此版本的一个非常细微的修改（通过）：

puts <<3*3,3
puts <<3*3,3
3

puts-line的打印次数呈指数增长。

$ ruby quine.rb | ruby | ruby
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
3

$ ruby quine.rb | ruby | ruby | ruby | ruby | ruby | ruby | ruby | wc -l
    3283

Lambda微积分-29

一个简单的lambda术语

(λu.(u u)(u u))(λu.(u u)(u u))

通过减少一个beta的收益来降低这个条件

((λu.(u u)(u u))(λu.(u u)(u u)))((λu.(u u)(u u))(λu.(u u)(u u)))

等等等等。这是经典的一个简单变体，(λu.u u)(λu.u u)在lambda演算中是一个quine，在这里双重自我应用意味着我们得到两倍的输出。

SH脚本，9

cat $0 $0

以指数速度增长。

运行为sh whatever.sh或将其设置为可执行文件。

Windows版本在这里。

直流11

非常简单：

6579792
dfP

每一代重复第一行：

$ dc growing_quine.dc
6579792
6579792
dfP

$ dc growing_quine.dc | dc | dc 
6579792
6579792
6579792
6579792
dfP

最后一行由以下指令组成：d复制堆栈上的最后一个值（6579792）（以便每次运行时再获得一个副本），f打印整个堆栈（一堆相同的数字），然后P将数字（6579792）打印为字节流，显示为dfP。

redcode（递归解决方案）

这是用著名的Imp 编写的redcode中最简单的战士的代码：

MOV 0, 1

执行后，代码将其单条指令的副本写入内存中的下一个地址。然后执行它，等等。

Python 3-55

print(open(__file__).read())
f=lambda:print('f()')
f()

通过使用单个字符文件名替换__ file__并将文件保存为该文件，可以使此过程更短，但是我觉得这个答案更符合问题的实质。一轮迭代后，它输出：

print(open(__file__).read())
f=lambda:print('f()')
f()
f()

小话，125 61 57

高尔夫版本看起来几乎不可读，因此我将首先进行解释（并使用真实的标识符）。

这是“最奇怪的产生堆栈溢出方式”自修改方法的一种形式。

该方法打印出一个hello消息及其当前源（仅用于演示）。然后，修改代码以输出更长的字符串并安装。最后，新代码被递归调用。

为了保护自己免受立即失控的侵害，它允许用户在每个周期中进行确认。

在对象中编译：

eatMe_alice
   |msg mySource|

   mySource := thisContext method source.

   '**** Hello Alice' printCR.
   '  ---- my current code is:' printCR.
   mySource printCR.
   '  ---------------' printCR.

   (UserConfirmation confirm:'Again? ') ifTrue:[
       Object compile:
            (mySource
                copyReplaceString:'Hello ','Alice'
                withString:'Hello ','Alice !').
       self eatMe_alice
   ]

通过向任何对象发送“ eatMe_alice”来开始表演；零将做：

nil eatMe_alice

一个不错的变体是不递归地调用新代码，而是通过展开调用栈并重新进入新方法来迭代地调用。这样做的好处是不会导致递归异常。为此，将递归调用（“ self eatMe_alice”）替换为：

thisContext resend

打高尔夫球：

显然，不需要打印和自叫，所以最简单的（对于高尔夫）是简单地在我自己的来源后面添加评论并返回。副作用是，它还会在下一次通话时安装...

x|s|Object compile:(s:=thisContext method source,'""').^s

SH脚本，12 8 7

用以下方式存储文件

sed p *

在其自己的空目录中，然后使用sh [file]或设置可执行文件从该目录运行。

具有8个字符的旧替代方法，但不需要自己的目录。用以下方式存储文件

sed p $0

并使用sh [file]或设置可执行文件运行。

12个字符的旧替代方法：

sed -i- p $0

这实际上将输出到程序文件本身，但是未指定输出位置。以指数速率复制自己。

JavaScript，41个，40个字符

function f(){console.log(f+"f(f())")}f()

第一次运行它时，它将最终输出自身;f()。输出的后续运行导致每个“输入”源打印两次。

alert会短一些，console.log但我不认为多个警报对话框是“ the”输出，而在控制台中调用多行作为输出似乎是合理的。

J，1个字节

'

在线尝试！

显然，开放报价给出了开放报价错误：

|open quote
|   '
|   ^
|[-1] /home/runner/.code.tio

请注意，根据J解释器的性质，错误将打印到STDOUT而不是STDERR。

当以上代码作为代码运行时，将输出：

|open quote
|   |   '
|       ^
|[-2] /home/runner/.code.tio

然后

|open quote
|   |   |   '
|           ^
|[-2] /home/runner/.code.tio

等等。每次代码运行时，第二行都用四个字节左填充|   ，从而满足了这一挑战的要求。

J，适当的quine变体，25字节

echo,~'echo,:~(,quote)'''

在线尝试！

产出

echo,:~(,quote)'echo,:~(,quote)'

然后，它在单独的行上两次输出自身：

echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'

然后

echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'

等等。

第一个输出是标准J quine的简单变体。所添加的,:~元素在垂直方向上串联起来，在其中将生成的2D数组打印为同一字符串的两行。

Windows .BAT，25

@COPY %~nx0+%~nx0 CON>NUL

以指数速度增长。

等效的SH版本在这里。

网状，11字节，无竞争

"'34'coo1o;

这是标准的quine框架，不同之处1在于每次迭代后都会打印一个额外的内容。在线尝试！

前几个输出：

"'34'coo1o;
"'34'coo1o;1
"'34'coo1o;11
"'34'coo1o;111

Microscript II，6个字节

非竞争性语言推迟了挑战。

"qp"qp

第一次迭代会qp在末尾添加一个额外的内容，而每个后续迭代会在开始时添加此原始程序的一个额外副本。

符文附魔，6字节

"'<S@>

在线尝试！

这一个很奇怪。我要做的就是~从乔·金（Jo King）发现的原始麦片中取出一个。

每增加一次运行<，都会在末尾附加另一个，例如：

"'<S@><<<<<<<<<

所有这些都不起作用。

EcmaScript 6（51字节）：

(_=x=>'(_='+_+Array(x++).join(','+_)+')('+x+')')(2)

它产生一个较长的自身版本，可以产生一个较长的自身版本，可以产生一个较长的自身版本，等等。

PHP，38

<?echo fgets(fopen(__FILE__,'r')).';';

它将在每次运行时添加一个分号。

ECMAScript 6（38个字符）

(f=_=>'(f='+f+')();(f='+f+')();')();

哪个输出：

(f=_=>'(f='+f+')();(f='+f+')();')();(f=_=>'(f='+f+')();(f='+f+')();')();

编辑

您可以这样做（28个字符）：

(f=_=>'(f='+f+')();'+f())();

但是，它将无限递归，并且永远不会返回任何内容……但是可以通过执行以下操作（42个字符）来解决：

(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(3);

将输出：

(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(3);(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(2);(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(1);

普通Lisp，16个字符

(print `(or ,-))

当然，它仅是交互式的，但是能够引用当前的顶级表单可能是最小化满足规格要求的非平凡程序的唯一最佳方法。

真正有趣的是炸毁最快的东西。也许像

(print `(progn ,@(loop repeat (length -) collect -)))

朱莉娅66个字符

x="print(\"x=\$(repr(x))\\n\$x;\"^2)";print("x=$(repr(x))\n$x;"^2)

输出（134个字符）：

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

执行结果的结果（268个字符）：

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

下一个结果（536个字符）：

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

下一个结果（1072个字符）：

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

我希望这是按照规则进行的。

它产生更大的输出，并且输出本身是有效的源代码，再次产生更大的输出。

05AB1E，15字节，无竞争

0"DÐ34çý"DÐ34çý

在线尝试！

打印0"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý，
其中打印0"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý，
等等

Evoloop，9×9矩形（81个单元）

Golly随附的Evoloop细胞自动机支持以“ 类似奎尼 ”的方式复制自身的模式。具体来说，这些模式每个都包含一个“程序”。通过首先执行程序（创建子程序的“身体”），然后将程序复制到子程序中，图案便会自我复制。

上面的方法适用于更著名的“ Langton's Loops”细胞自动机以及Evoloop，但是Evoloop有一个有趣的区别，那就是很容易创建在每个后代中增长的模式。

（在我看来，更有趣的是Evoloop是一个简单的细胞自动机，其中包含可自我复制并以逼真的方式进化的模式！我认为，唯一能做到这一点的细胞自动机就是Evoloop及其后代然而，Evoloop的一个缺点是存在一个特定的“最佳”基因组；进化最终最终会收敛到这一基因组。）

现在，此提交有两个缺点。一个是不清楚细胞自动机的“输出”是什么。但是我认为，一个自我复制的自动机“足够接近”成一团。这当然也同样有趣！另一个缺点是这些模式不仅创建了它们自己的单个副本，而且还创建了一个副本。原始模式的每个副本都试图创建自己的无限多个副本，这些副本最终以破坏性的方式彼此交互。因此，我认为我已经在精神上满足了这项挑战的要求，但没有达到要求。

事不宜迟，此模式为：

022222220
270170172
212222202
202000212
272000272
212000202
202222212
271041032
022222250

这是模式，它的格式可以复制并粘贴到Golly中：

x = 9, y = 9, rule = Evoloop
.7B$BG.AG.AGB$BA5B.B$B.B3.BAB$BGB3.BGB$BAB3.B.B$B.5BAB$BGA.DA.CB$.6BE
!

好的，但是看起来像什么？看起来像这样：

在上面的动画中，您可以看到初始模式创建了一个更大的女儿，该女儿创建了一个更大的孙女，然后是一个更大的曾孙女，最后是一个更大的曾孙女，开始构造一个更大的孙女。孙女。如果您长时间运行此模式，它将永远持续这种状态（或者它们最终将被能够更快繁殖的进化生物所取代；我不确定）。

批量，26

将此代码放在任何.bat文件中，它将继续执行（无限循环），并且文件也会增长。

echo echo %0 ^>^> %0 >> %0

PYG（6）

P(Q,Q)

打印自己的源代码，以换行符分隔。第二代是

P(Q,Q)
P(Q,Q)

等等。

OIL，83个字节

0
0
1
1
1
4
1
11
4
1
11
1
2
2
1
12
18
10
18
1
32
22
1
18
26
4
26
8
18
11
6
17
4
26

它首先打印两行中的零，然后将每行与第1行进行比较（如果它们相等）（文件耗尽时就是这种情况），我们将打印单元格26中的内容。结果输出将看起来像一样，除了添加了33，它什么都不做。下次，将添加另一行，依此类推。

求助，WarDoq！，1个字节。

H

印刷品Hello, World!。

除H以外的其他字符是有效（且安全）的源代码（可打印Hello World的其他变体）。