您的任务是创建一个程序，该程序在运行时将自身作为输出返回（这被称为quine）。但是，此quine必须在被复制n次数时返回该quine，但是其每个字符都必须重复放置n时间，其中n是一个正整数。

如果您的原始程序是Derp：

Derp -> Derp (must return itself as output to be a quine)

DerpDerp -> DDeerrpp
(the "Derp" is copied twice, so each character in the output has to be copied twice)

DerpDerpDerp -> DDDeeerrrppp
etc. etc.

请记住，您可以在“基本”程序中使用空格，但是在“交织”时将其计为空格。说你的程序是

Derp 
{newline}

（换行符表示末尾的换行符，并且后面有多余的空格Derp）。当复制成为

Derp 
Derp 
{newline}

您必须输出

DDeerrpp  
{newline}
{newline}

请记住，。2之后还有多余的空格DDeerrpp。

规则和规格：

• 您的程序必须至少包含两个不同的字符（这意味着您的代码必须至少2个字节长）。
• 适用标准标准规则。

这是代码高尔夫球，因此以字节为单位的最短代码胜出！

裂变，6个字节

'!+OR"

在线尝试！ 尝试两份！ 尝试三个！

说明

这只是Fission标准quine。由于Fission在程序中具有明确的入口点，因此它确实可以应对这一挑战。特别是，通过复制程序，我们添加了另一个程序，该程序又R添加了另一个原子（指令指针）。由于源代码是环形的，因此执行的有效代码不会发生其他变化-对于每个原子，该代码在本地仍然看起来相同。但是，原子是在锁定步骤中执行的，因此它们打印的内容是交错的，并且我们在输出中获得每个字符的附加副本。

为了完整起见，我将简短地重申程序本身的工作方式。无论我们是否重复该程序（例如'!+OR"'!+OR"'!+OR"），每个原子都会看到以下代码：

R"'!+OR"'!+O

的 "切换字符串打印模式，使程序通过打印开始'!+OR直接输出到标准输出，这是所有除了报价奎因。然后'!设置原子的质量的字符代码!，+增量它，这给"，并O打印出来，同时破坏原子。该程序然后终止，因为没有原子了。

Python 2.7版，377 310 304 194 191字节！

这是我的第一次高尔夫，所以我没想到它会太好。但是我认为我提出的解决方案中的概念有些有趣，因此无论如何我都会发布它。

def f():
 import threading as T,inspect as i;global t,a,i
 try:t.cancel()
 except:a=0
 a+=1;t=T.Timer(1,d);t.start()
def d():print''.join(c*a for c in i.getsource(f)+i.getsource(d)+"f()")
f()

确实，这是一个奎因。您可以在这里尝试。它非常滥用检查模块。

如果尝试使用相同的源代码x2运行它，那么我们也将获得正确的输出。您可以在这里尝试。x3，x4等均可按预期工作。

不带解释：

def f():                                   # Defines a central function f
    import threading as T,inspect as i     # Imports threading and inspect
    global t,a,i                           # Global vars
    try:
        t.cancel()                         # Tries to cancel Timer from previous code
    except:
        a = 0                              # Reached when code is 1st copy; initializes a.
    a += 1                                 # a++; this is the number of copies thus far.
    t = T.Timer(1,d)               # Creates, then starts a timer to call function
    t.start()                              # d in 1 second.

def d():                                   # Prints out the source code; the quine part.
    print''.join(c*a for c in i.getsource(f)+i.getsource(d)+"f()")

f()                                        # Calls f()!

CJam，19个字节

{]W=s"_~"+T):Te*}_~

在线尝试！

怎么运行的

{               }_~  Define an anonymous code block (function).
                 _~  Push a copy, and execute the copy.
 ]W=                 Wrap the entire stack in an array and select its last element.
                     This discards whatever was on the stack before the original
                     code block, which is needed for subsequent iterations.
    s"_~"+           Cast the code block to string, push "_~", and concatenate.
                     This pushes the stringified source code on the stack.
          T):T       Push T (initially 0), increment it, and save the result in T.
              e*     Repeat each character in the stringified source code T times.

RProgN，66字节

重要的空白将成为我的死亡

[ "[ %q ] F 0 1 + `0 = `. { 0 m } R " ] F 0 1 + `0 = `. { 0 m } R 

讲解

[ "[ %q ] F 0 1 + `0 = `. { 0 m } R " ] F 0 1 + `0 = `. { 0 m } R   #
[                                                                   # Pop whatever is already on the stack, if anything.
  "[ %q ] F 0 1 + `0 = `. { 0 m } R "                               # This string contains basically the entire function.
                                      ] F                           # ] F duplicates the string, and then F formats it, which in this case puts the first string into the second at %q, surrounded by qoutes.
                                          0 1 + `0 =                # I needed an Incrementer, so I chose 0. 0, is conveniently, pre initilized at 0. And because RProgN is horrifying, you can remap the number functions as they're just more variables. So this increments 0 every time the group is called.
                                                     `. { 0 m } R   # Replace each character with itself repeated '0' times. Because '0' is an incrementer, each time the script is called, the amount of times the characters are repeated increase.

上帝，我是个怪物。

在线尝试！

Perl 5，107个字节

$_=q[$_=q[S];s/S/$_/;$a++;END{s/./$&x$a/eg;print if$a;$a=0}];s/S/$_/;$a++;END{s/./$&x$a/eg;print if$a;$a=0}

取消高尔夫：

$_ = '...INSERT_SOURCE_HERE...';      # Standard quine
s/INSERT_SOURCE_HERE/$_;
$a++;                                 # Count the number of repetitions
END {
    s/./$&x$a/eg;                     # Interweave
    print if $a;                      # Print...
    $a=0;                             # ...but only once
}

在线尝试！

Python 3中，122个 121 112字节

s='try:from atexit import*;n+=1\nexcept:n=1;register(lambda:[print(end=c*n)for c in"s=%r;exec(s);"%s])';exec(s);

在线试用： 一份 | 两份 | 三份 | 一式四份，并带有自动验证

怎么运行的

这使用标准的Python quine：将要执行的代码存储在变量中（作为字符串）；在该字符串中包括一些逻辑，以打印自身，之前的所有内容以及之后的所有内容；然后执行该字符串。

下面是通过字符串s执行的代码。

try:from atexit import*;n+=1
except:n=1;register(lambda:[print(end=c*n)for c in"s=%r;exec(s);"%s])

第一行无条件导入atexit模块，这将允许我们注册退出处理程序。尝试多次导入同一模块不会以任何方式影响脚本。然后尝试增加变量n，以跟踪执行了源代码的副本数。

仅在第一行包含错误时才执行第二行。第一次迭代就是这种情况，因为n仍未定义。在这种情况下，我们将n初始化为1并注册一个执行实际魔术的lambda。

注册的退出处理程序

lambda:[print(end=c*n)for c in"s=%r;exec(s);"%s]

将在程序完成前立即调用。Lambda本身会创建字符串"s=%r;exec(s);"%s- %r创建正确的参数的字符串表示形式（s），其中包括单引号和引号本身之间的所有内容-然后遍历其字符。对于每个字符c，我们只需打印n个c副本。c*n作为命名参数传递end给print意味着将不附加换行符。

CJam，14个字节

{s"_~"+]:.+}_~

在线尝试！

说明

{s"_~"+]:.+}_~
{s"_~"+    }_~ Basic quine operator.
       ]:.+    Append each character to corresponding element of the previous result if existed.