Sua tarefa é criar um programa que, quando executado, retorne como saída (isso é conhecido como quine). No entanto, esse quine deve, quando é copiado nvezes, retorna o quine, mas com cada um de seus caracteres duplicados nos nhorários do local , onde né um número inteiro positivo.

Se o seu programa original for 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.

Lembre-se de que você pode ter espaços em branco em seu programa "base", mas eles são contados ao "entrelaçar". Diga que seu programa é

Derp 
{newline}

(A nova linha significa uma nova linha à direita e há um espaço extra após a Derp). Quando duplicado para se tornar

Derp 
Derp 
{newline}

Você deve produzir

DDeerrpp  
{newline}
{newline}

Lembre-se de que há 2espaços extras após o DDeerrpp.

Regras e especificações:

• Seu programa deve conter pelo menos dois caracteres distintos (o que implica que seu código deve ter pelo menos 2 bytes).
• Aplicam- se regras padrão de quine .

Isso é código-golfe , então o código mais curto em bytes vence!

Fissão , 6 bytes

'!+OR"

Experimente online! Tente duas cópias! Tente três!

Explicação

Esta é apenas a norma da fissão . Por acaso, trabalha para esse desafio, porque a Fission tem pontos de entrada explícitos no programa. Em particular, duplicando o programa, adicionamos outro Rque adiciona outro átomo (ponteiro de instrução). Como o código fonte é toroidal, o código efetivo que está sendo executado não muda de outra maneira - para cada átomo, o código ainda parece o mesmo localmente. No entanto, os átomos são executados na etapa de bloqueio, para que as coisas que eles imprimem sejam intercaladas e tenhamos uma cópia adicional de cada caractere na saída.

Para completar, em breve reiterarei como o próprio programa funciona. Independentemente de repetirmos o programa ou não (por exemplo '!+OR"'!+OR"'!+OR"), cada átomo vê o seguinte código:

R"'!+OR"'!+O

O "modo de impressão de seqüência de caracteres alterna, para que o programa inicie imprimindo '!+ORdiretamente em STDOUT, que é tudo de quine, exceto a cotação. Em seguida, '!define a massa do átomo para o código de caractere de !, +incrementa-o, o que fornece "e Oimprime enquanto destrói o átomo simultaneamente. O programa então termina, porque não há átomos restantes.

Python 2.7, 377 310 304 194 191 bytes!

Este é o meu primeiro golfe, então não esperava que fosse muito bom. Mas eu pensei que o conceito na solução que eu criei era um pouco engraçado, então eu estou postando de qualquer maneira.

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()

De fato, isso é um problema; você pode tentar aqui . Abusa bastante o módulo de inspeção.

Se tentarmos executá-lo com o mesmo código fonte x2, obteremos a saída correta também; você pode tentar isso aqui . x3, x4, etc. todos funcionam como esperado.

Ungolfed com explicação:

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 bytes

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

Experimente online!

Como funciona

{               }_~  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 bytes

Espaço em branco significativo seja a minha morte

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

Explicado

[ "[ %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.

Bom Deus, eu sou um monstro ...

Experimente online!

Perl 5, 107 bytes

$_=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}

Ungolfed:

$_ = '...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
}

Experimente online!

Python 3 , 122 121 112 bytes

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);

Experimente Online: uma cópia | duas cópias | três cópias | quatro cópias, com verificação automática

Como funciona

Isso usa o padrão Python quine: Armazene o código que você deseja executar em uma variável (como uma string); inclua alguma lógica nessa sequência para imprimir a si mesma, tudo antes e depois; depois execute essa string.

O código que é executado através da string s é o seguinte.

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

A primeira linha importa incondicionalmente o módulo atexit , o que nos permitirá registrar um manipulador de saída. Tentar importar o mesmo módulo várias vezes não afeta o script de forma alguma. Em seguida, ele tenta incrementar a variável n , para acompanhar quantas cópias do código fonte foram executadas.

A segunda linha é executada apenas se a primeira contiver um erro. Este será o caso na primeira iteração, pois n ainda não está definido. Nesse caso, inicializamos n como 1 e registramos um lambda que executa a mágica real.

O manipulador de saída registrado

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

será chamado logo antes da conclusão do programa. O próprio lambda cria a string "s=%r;exec(s);"%s- %rcria uma representação de string do ( s ) argumento ( s ) correto ( s ), que inclui tudo entre as aspas simples e as próprias aspas - e itera sobre seus caracteres. Para cada caractere c , simplesmente imprimimos n cópias de c . Passar c*ncomo argumento nomeado endpara printsignifica que nenhum avanço de linha será anexado.

CJam , 14 bytes

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

Experimente online!

Explicações

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