制作一台通用的整数打印机固然很好，但是编写一个可以打印许多不同数字的代码很麻烦。制作输出数字的脚本会更容易，但同时会为您提供一个新的脚本以获取下一个数字吗？

挑战：

编写输出单个整数N和可执行代码的代码。应该输出下一个代码N+1和可以输出的代码N+2。继续这条路，直到到达N = 15。（最后打印的号码应该是15）。

规则：

• 没有输入（假设输入为空）。
• 允许使用完整的程序或功能或其他方便的格式。
• 第一个代码应该输出1。
• 您无法输出前导零。例如，你不能打印01了1。
• 输出必须采用格式N, Code_for_N+1。请注意，输出用逗号和单个空格分隔。的代码N+1没有周围的引号。 N , Code_for_N+1不接受（逗号前面的空格）。尾随换行符可以。
• 输出的第一个字符必须是数字。（没有前导空格，或者ans = N）。
• 打印的号码不应成为下一个代码的一部分（代码可以包含该号码，但您不能将输出号码作为代码的一部分）
  • 示例：的输出N=2可以是：2, printer 2。在这种情况下，printer 2是的代码N=3。您不能使用整个输出：2, printer 2作为的代码N=3。
• 脚本可能使用不同的语言
• 数据类型无关紧要（数字可以是字符串），但是不能被任何东西（引号，括号等）包围。
• 如果输出了一个代码，N=15那么它必须要么打印STOP!（请参阅奖励），要么根本不打印任何内容（甚至不包括空格或换行符）。
  • 的代码N=15不能崩溃（但可以输出到STDERR）。
  • 如果N=15打印输出代码16或其他任何内容（赠金情况除外），您将失去资格。
• 不允许使用内置的quine运算符。
• 不允许通过文件系统访问源文件。

奖金：

-10字节（如果打印15的代码也产生了打印“ STOP!” 的代码）

使用Python语法的示例：（显然，这些仅适用于选定的整数，而不是1到15。）

N = 1
print "1, print 2"
1, print 2

---
N = 15
print 15
15

---
N = 15   (Qualifies for the -10 bytes bonus)
print "15, print 'STOP!'"
15, print 'STOP!'

print 'STOP!'
STOP!

----

N = 15   (Qualifies for the -10 bytes bonus)
print "15, disp('STOP!')"
15, disp('STOP!')        (disp('STOP!') outputs STOP! in MATLAB)

----
N = 15   (This one is not OK. The submission is disqualified)
print "15, print 16"
15, print 16

适用标准高尔夫规则！最小的代码（对于N = 1）以字节为单位！

Pyth + ///，15字节-10 = 5

pPt`S15", STOP!

这将打印1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, STOP!在Pyth，采取range(1,15+1)和剥离的开始和结束括号，并打印出来，紧接着“STOP！”。

接下来的14个程序位于///中，它直接输出所有不包含/或的程序\。所以第二个程序

2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15

给出2和第三个程序3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15。倒数第二个程序15, STOP!打印15, STOP!，所以最后一个程序是STOP!。

JavaScript，131238-10 = 131228字节

天真的方法比预期的要糟糕。事后看来，我应该预料到了。但我想还是应该分享。完整代码在这里。

想法：迭代地转义并添加 N-1, ...

alert("14,alert(\"15, alert(\\\"STOP!\\\")\")")

CJam，26 25 24字节

1{", "2$)@"_~"](_F<@*}_~

在线尝试。

后续程序仅使第一个数字递增。这将运行该程序16次。

或相同分数的奖金：

1{", "\2$)_G<\@`+"_~"+"STOP!"`?}_~

在线尝试。

后续程序仅使第一个数字递增。这将运行该程序16次。

奖金的替代解决方案：

1{", "\2$)Gmd@`+"_~"+"STOP!"`\?}_~

JavaScript（ES6），62 61字节-10奖励= 51得分

_=>"1, "+(f=n=>`_=>"`+(n<16?n+`, "+(${f(n+1)})`:`STOP!"`))(2)

说明

一种不读取其自身源代码且长度也不长的解决方案。

第一个程序构造所有其他15个程序，并使用递归函数将它们相互嵌套。我通过嵌套函数本身（然后在输出过程中将其强制转换为字符串）而不是字符串来解决反斜杠问题。

_=>
  "1, "                // print the first number
  +(f=n=>`_=>"`+(      // f = recursive function for printing program N
    n<16?              // for programs 2 - 15:
      n+`, "+(${       // add N to the output of the nested function
        f(n+1)         // nest the code of program N + 1
      })`
    :`STOP!"`          // program 16 just outputs "STOP!" for the bonus
  ))(2)                // start from program 2

测试

var nextProgram = '_=>"1, "+(f=n=>`_=>"`+(n<16?n+`, "+(${f(n+1)})`:`STOP!"`))(2)',
    n = 1;
while(nextProgram) {
  result.textContent += "Program " + n++ + ": " + nextProgram + "\n";
  var output = eval("(" + nextProgram + ")()");
  result.textContent += "   Output: " + output + "\n\n";
  var index = output.indexOf(",");
  nextProgram = index > 0 ? output.substr(index + 2) : null;
}

<pre id="result"></pre>

Matlab，226212-10 = 202字节

感谢@StewieGriffin的几个字节=）

'awFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)

第一部分是一个字符串，代表第二行（下面），即实际代码（仅移位9）。在Matlab中，字符串是填充有字符的矩阵，因此您只需添加/减去标量就可以轻松执行移位。因此，程序只再次打印出相同的字符串*，再加上相同的字符串，但移位后得到代码。

*不完全是：第一个字节是计数器，每次迭代都需要增加。

从这里偷偷地偷了绳子的奎纳花招。

'awFjw|Dro)w1:26B?G:>DwF0\}xy*0Dnu|nDwFdw~v;|}{1w1:26B?2505)05<B5w1:24:5w1;Cnwm25<B5>B5w1;Cnwm26B500fDnwmDmr|y1w2';
n=ans;if n(1)-96>15;n='Stop!';else;n=[num2str(n(1)-96),', ',39,n(1)+1,n(2:end),39,59,n(2:end)-9,''];end;disp(n)

这里是从控制台复制的序列的最后几行：

>> 'mwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
13, 'nwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
>> 'nwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
14, 'owFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
>> 'owFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
15, 'pwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
>> 'pwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
STOP!

JavaScript，50 47 44 42 44 ^*字节

a=_=>(x=1)+(x<15?", a="+a:"").replace(x,x+1)

该函数提取自己的主体（只是a）并在其中进行替换。使函数体具有JavaScript的内置功能，尽管不是显式的quine运算符（如果无效），则将删除答案。

a=_=>(x=1)+(x<15?", a="+a:"").replace(x,x+1);
alert(a());

万一它不能正确地嵌入其中（因为对我而言，它不能正常工作），您可以在那里看到一个示例。

^{*-好像代码片段产生的结果不带a=，因此无法进行进一步的调用}

Python的2.7.10，196 92 - 10 = 82个字节

呜呜！很好玩 现在要短得多。：P

n=1;a='n=%d;a=%r;print n,a%%(n+1,a)if n!=15else"STOP!"';print n,a%(n+1,a)if n!=15else"STOP!"

说明：

我从这个开始：

a='a=%r;print a%%a';print a%a

那只是一个简单的想法。这是添加一个计数器的结果：

n=1;a='n=%d;a=%r;print n,a%%(n+1,a)';print n,a%(n+1,a)

n是在开始时打印的计数器变量。然后，当它的打印n=部分，它替换n+1了%d。因此，从这里开始它将无限计数。

这是最终版本。它添加了一个if子句以在15处停止，并显示“ STOP！”。也一样

n=1;a='n=%d;a=%r;print n,a%%(n+1,a)if n!=15else"STOP!"';print n,a%(n+1,a)if n!=15else"STOP!"

旧代码：

a= ['if num==15:print"STOP!!!";exit()','print num','print"a=",a','print"num=",num+1', 'for s in a:print s']
num= 1
print num
if num==15:print"STOP!!!";exit()
print"a=",a
print"num=",num+1
for s in a:print s

永远不会赢，但很有趣。：P现在更短了，尽管我仍然没有机会。：P

PowerShell中，（215-10）= 205个 197 167 106 104 103字节

$d='$c=(,1*{2}).count;$d={0}{1}{0};(("$c, $d"-f[char]39,$d,($c+1)),$c)[$c-eq15]';"1, $d"-f[char]39,$d,2

_{（如果您唯一的工具是PowerShell，那么每个问题都像钉子一样。等等...）}

从本质上讲，我们从设置$d等于原始代码几乎成对的大字符串开始。它输出1，然后$d与格式操作者-f正确地填充{0}，{1}，{2}替身，递增{2}的数量,1*{2}由每次一部分。

,x*yPowerShell中的操作会创建一个新的y项目数组，每个项目都等于x。例如，,2*3等效于@(2,2,2)。

这意味着，第一个输出将是1, $c=(,1*2).length;$d=(etc...)，因此在执行第二个代码时，$c它将等于array的计数@(1,1)或2，等等。请注意，$c原始代码不会在后续运行中用作变量。

通过简单地计算是否$c等于等于15然后索引到数组来打印15时停止。第0个元素$c, $d如上所述，另一个为just 15。因此，当$c为15时，它将输出，15而没有其他输出。没有资格获得奖金，因为"15, {0}STOP!{0}" 10个字符太长能使-10值得。

需要宽度>〜150的PowerShell终端。或者，您可以在复制粘贴代码时手动删除多余的换行符（该端子在输出换行中有用地插入）。或者，您可以将输出捕获到变量中，然后重新执行该变量。等等。

_{编辑1-通过删除“ STOP！”保存一些字节 措辞。
编辑2-杜尔（Durr），不要每次都使用.length，只需调用一次即可。
编辑3-不需要是奎因，因此初始运行时间可以短得多。
编辑4-从使用字符串更改为要计算的数组$c，节省了两个字节。我很确定这对于这种方法几乎是最佳的。
编辑5-通过直接计算相等而不是修改来保存另一个字节}

JavaScript，79-10 = 69字节

s='STOP!';for(i=15;i;){s=i--+',alert("'+s.replace(/[\\"]/g,"\\$&")+'")'};alert(s)

Function.prototype.toString根本不使用任何方式。

Befunge，57-10 = 47字节

1:'!`'#*j:.',,1+:9`''*'0++,1#;:0g:48*`j@,1+;"!POTS",,,,,@

这个很棒。在这里尝试。

批处理，73 + 5-10 = 68字节

@set a=STOP!
@for /l %%a in (15,-1,1)do @set a=%%a, @echo !a!
@echo %a%

需要，CMD /V:ON所以我为此添加了5个字节。

Python 2.7，107个字符

通过使用递归而不是写一个quine，我认为我可以节省很多，这是事实，但还不够好。尽管不是赢家，但我认为这种方法很有趣。

我从组成一个N = 4的字符串开始，转义了\和"字符。

print "1, print \"2, print \\\"3, print \\\\\\\"4, print \\\\\\\\\\\\\\\"STOP!\\\\\\\\\\\\\\\"\\\\\\\"\\\"\""

然后，我创建了一个lambda函数，该函数使用递归基于起始索引和终止索引创建此字符串。就是这个：

l=lambda n,m:str(n)+", print "+"\\"*(2**(n-1)-1)+"\""+l(n+1,m)+"\\"*(2**(n-1)-1)+"\"" if n<m else "STOP!"

像这样使用它：

print l(1,15)

输出： [32902个字符，太长而无法处理]

因此，看来我的kolmogorov复杂度方法并不那么成功;-)

高炉，28字节

\x10代表文字字节（十进制值16）。整数输出为整数（字节）。因此，第一个字符输出为\x01。然后程序打印“，”。打印自己的来源时，它会+在开始时额外打印。

+.<-<<.>.>[[<]>.[.>]<[-]], \x10

说明：

+.                                  Increment number and print
  <-                                Pre-decrement loop counter
    <<.>.>                          Print comma and space from own source
          [             ]           Only execute if loop counter != 0
           [<]>.                    Move to left of source, then print `+`
                [.>]                Print entire source.
                    <[-]            Zero out the loop counter so this program halts.
                         , \x10     The comma, space, and loop counter used earlier.
                                    Input is empty, so `,` doesn't do anything.

请注意，您不能在标准解释器中运行此命令，因为它在输入中需要一个十六进制文字。您还需要一个特殊的端子来使十六进制输出正常工作。

巴什78 74 73-10 = 63字节（例如，无法获胜）

p='if(($((++a>15))));then unset a p;fi;echo ${a-STOP\!}${p+, $p}';eval $p

来晚了，但是看到bash还没有尝试过，所以试了一下。第一个挑战湾区和类似quine的难题。他们很好玩！

说明：

这工作，因为a步骤从1到15，然后unset沿p。脚本（存储在中p）将它们同时打印出来set并显示为“ STOP！”。除此以外。最初unset a为set0，因为它出现在算术扩展中。

𝔼𝕊𝕄𝕚𝕟，30个字符/ 47个字节（非竞争性）

⟮a=1)+(a<ḏ?⬬+ⒸⅩ222+ᶈ0:⬯)ē(a,⧺a

Try it here (Firefox only).

终于找到了一个很好的真true。

说明

这是我使用的真正的奎因： ⟮ⒸⅩ222+ᶈ0

您在我的回答中看到了吗？希望你们所有人都能从那里扩展。

小桶 + PHP，19-10 = 10字节

ï_(. \,,,)\!POTS(,

从1到15计数，然后停止。蒂奥

小桶，13个字节

ï_(. \,,,).