为应对这一挑战，您必须创建一个程序，该程序需要一个整数x并x多次输出其源代码。

规则

• 这是代码高尔夫，目的是使您的程序具有最少的字节数

• 如果提交函数，则该函数必须x作为参数，并且x多次将整个代码返回或打印到STDOUT。功能体也不能为空

• 如果您提交lambda，则不需要将其分配给变量

• 适用标准漏洞限制。

• 禁止空程序

• 您的程序仅在x整数大于或等于0 时才起作用

• 您的程序也可能不会直接读取其源代码的任何部分

Python 2，50个字节

请注意尾随逗号和换行符。

s='s=%r;print s%%s*input(),\n';print s%s*input(),

在线尝试！

Japt，14个字节

"iQ ²pU"iQ ²pU

在线尝试！

说明

"iQ ²pU"iQ ²pU
"iQ ²pU"       # Take this string
        iQ     # Prepend a quote
           ²   # Double the string (= source code)
            pU # Duplicate input times

RProgN 2，8字节

{`{.*¶}{

RProgN2 Loop quine对此特别有效！

{     } # A function literal
       {# Without a matching }, this loops back to the second instruction, which essentially runs the function. This is a bug, but it works to make the "Looping Quine".
 `{.    # Append the literal {, stringifying the function.
    *   # Multiply the stringified function by the input.
     ¶  # Terminate the program.

在线尝试！

Mathematica，40 33字节

感谢lanlock4节省了7个字节！

StringRepeat[ToString[#0], #1] & 

纯函数采用非负整数参数。ToString[#0]是访问当前纯函数定义的标准Mathematica方法；StringRepeat[..., #1]将该字符串的副本连接在一起（输入）。例如，

StringRepeat[ToString[#0], #1] & [2]

产量：

StringRepeat[ToString[#0], #1] & StringRepeat[ToString[#0], #1] & 

V，11个字节

ÀñAÀÑ~"qpx

在线尝试！

这是对标准可扩展V quine的极其琐碎的修改。我们只是使用À它来运行arg1次。

dc，31个字节

[[1-rd91Pn93P[dx]Pdx]s.rd0<.]dx

在线尝试！

说明：

[[1-rd91Pn93P[dx]Pdx]s.rd0<.]dx
[     91Pn93P[dx]P          ]dx  # Same old regular quine
 [1-rd            dx]s.rd0<.     # Loop until the counter is zero

Python 2，70个字节

此解决方案适用于x=0。后面只有一条换行符。

s='s=%r;exec"print%%r;"%%(s%%s)*input()';exec"print%r;"%(s%s)*input()

在线尝试

Python 2，60个字节（无效）

假设x>=1，但OP阐明x可以为零。后面只有一条换行符。

s='s=%r;print(s%%s*input())[:-1]\n';print(s%s*input())[:-1]

在线尝试

欠载，12个字节

(a(:^)*~^):^

在线尝试！

函数提交，因为欠载没有其他方法可以接受输入。（TIO链接显示输入的数字4，并添加代码以打印输出结果）。

这只是一个通用的quine构造函数(a(:^)*):^，加上~^（“使副本数量等于参数”）。

Japt，14个字节

*E îQi"*E îQi"

在线尝试！

果冻，10字节

“;⁾vṾẋɠ”vṾ

在线尝试！

怎么运行的

“;⁾vṾẋɠ”vṾ  Main link. No arguments.

“;⁾vṾẋɠ”    Set the argument and the return value to the string ';⁾vṾẋɠ'.
         Ṿ  Uneval; yield '“;⁾vṾẋɠ”'.
        v   Eval ';⁾vṾẋɠ' with argument '“;⁾vṾẋɠ”'.
  ⁾vṾ           Yield 'vṾ'.
 ;              Concatenate '“;⁾vṾẋɠ”' and 'vṾ', yielding the source code.
      ɠ         Read an integer from STDIN.
     ẋ          Repeat the source code that many times.

GNU Make，49个字节

$(foreach ,$(shell seq $1),$(strip $(value $0))) 

Make将在单个空格之间加入副本，因此我必须在末尾添加其他空格字符，并strip在中间加上一个空格，以便忠实地遵循要求。

Pyth，17个字节

j*]jN*2]"j*]jN*2]

在线尝试！

简单扩展到众所周知的jN*2]"jN*2]奎因，但可能可以打下来

Betaload，203字节

为清楚起见添加了换行符：

(a(:^)*(!()):#(}:(:)~^a((::*:**:*)*)~*(~*)*~(*)~^a*(*)*{)>(0)(!()){:^}(1)(){:^}(2)(:*){:^}(
3)(::**){:^}(4)(:*:*){:^}(5)(::*:**){:^}(6)(:*::**){:^}(7)(::*::***){:^}(8)(:*:*:*){:^}(9)(
::**::**){:^}R^^S):^

我给自己一个限制，它必须从STDIN读取，而不是像通常的欠载回答那样从堆栈的顶部读取。我还使用了正确的十进制输入，它构成了大部分代码。

说明：

我将程序包装在quine-wrapper中：(a(:^)*和):^。这意味着在quine包装器中的所有代码将在堆栈底部具有程序的源代码。

为了将数字转换为普通的教堂数字，我使用了用代码替换每个数字并乘以10并添加该数字的技术：

0 -> (::*:**:*)*
1 -> (::*:**:*)*(:)~*(*)*
2 -> (::*:**:*)*(::)~*(**)*
3 -> (::*:**:*)*(:::)~*(***)*

这里有很多重复，因此让我们将其打包到一个子程序中，该子程序将从堆栈的顶部获取教会数字，并使用它来构造“数字字符串”：

:(:)~^a((::*:**:*)*)~*(~*)*~(*)~^a*(*)*

我将其放入新环境中，以便可以快速访问它：

#(}:(:)~^a((::*:**:*)*)~*(~*)*~(*)~^a*(*)*{)>

现在，我可以为创建替换代码R。R使用堆栈的顶部元素形成查找表，以用Betaload代码替换STDIN中的字符串。它是这样的：

()
(0)(code for 0)
(1)(code for 1)
(2)(code for 2)
...
R

但是，我们可以使用刚刚制作的子程序来生成代码段：

(0)(!()){:^}
(1)(){:^}
(2)(:*){:^}
(3)(::**){:^}
...

当R运行时，它会转换输入一系列子程序是建立一个教堂数字的。当执行该子程序时，它将在堆栈的下一个元素（0，该元素放在较早位置）上创建该教堂数字。这意味着，在之后R^，堆栈上的最高值将是教堂数字。然后，我们再^有一次将教堂数字应用于堆栈中的最后一个元素（程序的源代码）以获得答案。

有趣的事实：我已经为这个提交的MD了几个月。在误解了一个问题（我似乎再也找不到了）之后，我保留了它。我必须从回收站中将其挖掘出来，然后才能在此处发布。

05AB1E，23个字节

"34çìDJ¹.D»"34çìDJ¹.D»

在线尝试！

Python 2，41个字节

_="input('_=%r;exec _'%_*input())";exec _

在线尝试！

是否使用input而不是hacky输出print，因为print有一个怪异的错误，涉及到在不应该...时打印换行符的问题。退出并出现EOF错误。

说明：

_="input('_=%r;exec _'%_*input())"; # Set _ to a string
exec _                              # Execute that string
input(                        )     # "print"
      '_=%r;exec _'%_               # The source code with _ formatted in
                     *input()       # Actual input many times

05AB1E，27 25字节

"34çs«DJ¹FD,"34çs«DJ¹FD,

在线尝试！

Pyth，13个字节

*jN*2]"*jN*2]

测试套件

标准的Pyth quine加两个*重复。

Perl，48个字节

print"$_\47"x(2*pop)for'print"$_\47"x(2*pop)for'

\47是单引号（'）的八进制转义。它在双引号（"）内解释，但在单引号内不解释。

JavaScript的ES6，27 37个字节

_=>alert(`${f.name}=${f}`.repeat(_))

编辑

+10个字节（如果f=还应显示）

f=

_=>alert(`${f.name}=${f}`.repeat(_))

f(2);

CJam，20 12字节

Martin Ender节省了8个字节

{"_~"+ri*}_~

在线尝试！

排骨

{       e# Begin a block literal:
 "_~"+  e#  Add whatever's on the stack to the beginning of the array ['_', '~'].
 ri*    e#  Repeat the resulting array a number of times equal to the input.
}       e# Close the block. Push it on the stack.
_~      e# Copy it and run it.

PHP，194字节

<?php $a="PD9waHAgJGE9IiMiOyRpPSRhcmd2WzFdO3doaWxlKCRpLS0pZWNobyBzdHJfcmVwbGFjZShjaHIoMzUpLCRhLGJhc2U2NF9kZWNvZGUoJGEpKTs=";$i=$argv[1];while($i--)echo str_replace(chr(35),$a,base64_decode($a));

在线尝试！

一点也不像b64一样容易打高尔夫球。

Go，257254字节

这让我很痛苦。

package main;import(."fmt";."strings";."strconv";."os");func main(){s:="package main;import(.\"fmt\";.\"strings\";.\"strconv\";.\"os\");func main(){s:=%q;n,_:=Atoi(Args[1]);Print(Repeat(Sprintf(s,s),n))}";n,_:=Atoi(Args[1]);Print(Repeat(Sprintf(s,s),n))}

在线尝试！

Microscript II，22个字节：

"v{lqp}sN*h"v{lqp}sN*h

Microscript II，20字节（但在技术上无效，因为它访问代码块的源代码）：

{s""+`"~sN*"s`+}~sN*

C，144116字节

i;main(a){for(i=getchar()-48;i--;)printf(a="i;main(a){for(i=getchar()-48;i--;)printf(a=%c%s%c,34,a,34);}",34,a,34);}

Python 3，69字节

s='s=%r\nx=int(input())\nprint(s%%s*x)\n'
x=int(input())
print(s%s*x)

C＃（Visual C＃交互式编译器），115字节

n=>{var s="n=>{{var s={0}{1}{0};for(int i=0;i++<n;)Write(s,(char)34,s);}}";for(int i=0;i++<n;)Write(s,(char)34,s);}

在线尝试！

05AB1E，17 个字节

0"D34çý×?"D34çý×?

通过添加修改默认quine 。0"D34çý"D34çý×?

在线尝试。

说明：

0                   # Push 0 to the stack
                    #  STACK: [0]
 "D34çý×?"          # Push the string 'D34çý×?' to the stack
                    #  STACK: [0, 'D34çý×?']
          D         # Duplicate this string
                    #  STACK: [0, 'D34çý×?', 'D34çý×?']
           34ç      # Push '"' to the stack
                    #  STACK: [0, 'D34çý×?', 'D34çý×?', '"']
              ý     # Join the stack by this '"' delimiter
                    #  STACK: ['0"D34çý×?"D34çý×?']
               ×    # Repeat the string the (implicit) input amount of times
                    #  input = 2 → STACK: ['0"D34çý×?"D34çý×?0"D34çý×?"D34çý×?']
                ?   # Output to STDOUT without trailing newline