Il tuo compito è quello di creare un programma che, quando eseguito, si restituisce come output (questo è noto come un quine). Tuttavia, questo quine deve, quando viene copiato i ntempi, restituire il quine, ma con ciascuno dei suoi caratteri duplicato nei ntempi del luogo , dove nè un numero intero positivo.

Se il tuo programma originale è 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.

Tieni presente che puoi avere spazi bianchi nel tuo programma "base", ma vengono conteggiati quando si "intrecciano". Di 'che il tuo programma è

Derp 
{newline}

(La nuova riga indica una nuova riga finale e dopo lo spazio c'è uno spazio extra Derp). Quando duplicato per diventare

Derp 
Derp 
{newline}

Devi produrre

DDeerrpp  
{newline}
{newline}

Tieni presente che ci sono 2spazi extra dopo il DDeerrpp.

Regole e specifiche:

• Il programma deve contenere almeno due caratteri distinti (il che implica che il codice deve essere lungo almeno 2 byte).
• Si applicano le regole standard di Quine .

Questo è code-golf , quindi vince il codice più breve in byte!

Fissione , 6 byte

'!+OR"

Provalo online! Prova due copie! Prova tre!

Spiegazione

Questo è solo il quine standard Fission . Capita di funzionare per questa sfida, perché Fission ha punti di ingresso espliciti nel programma. In particolare, duplicando il programma, ne aggiungiamo un altro Rche aggiunge un altro atomo (puntatore alle istruzioni). Poiché il codice sorgente è toroidale, il codice effettivo in esecuzione non cambia altrimenti - per ogni atomo, il codice sembra sempre lo stesso localmente. Tuttavia, gli atomi vengono eseguiti in fase di blocco, in modo che le cose che stampano siano interlacciate e otteniamo una copia aggiuntiva di ciascun carattere nell'output.

Per completezza, ripeterò a breve come funziona il programma stesso. Indipendentemente dal fatto che ripetiamo il programma o meno (ad esempio '!+OR"'!+OR"'!+OR"), ogni atomo vede il seguente codice:

R"'!+OR"'!+O

La "modalità di stampa alterna stringa, in modo che il programma inizia stampando '!+ORdirettamente su STDOUT, che è tutto il Quine, tranne la citazione. Quindi '!imposta la massa dell'atomo sul codice carattere di !, lo +incrementa, il che lo dà "e lo Ostampa mentre contemporaneamente distrugge l'atomo. Il programma quindi termina, perché non sono rimasti atomi.

Python 2.7, 377 310 304 194 191 byte!

Questo è il mio primo golf, quindi non mi aspettavo che fosse troppo bello. Ma ho pensato che l'idea nella soluzione che mi è venuta fosse in qualche modo divertente, quindi la sto pubblicando comunque.

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

In effetti, questo è un quine; puoi provarlo qui . Abusa il modulo di ispezione piuttosto difficile.

Se proviamo a eseguirlo con lo stesso codice sorgente x2, otteniamo anche l'output giusto; puoi provarlo qui . x3, x4, ecc. funzionano tutti come previsto.

Ungolfed con spiegazione:

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 byte

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

Provalo online!

Come funziona

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

Significativo spazio bianco sia la mia morte

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

spiegato

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

Buon Dio, sono un mostro ...

Provalo online!

Perl 5, 107 byte

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

Provalo online!

Python 3 , 122 121 112 byte

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

Provalo online: una copia | due copie | tre copie | quattro copie, con verifica automatica

Come funziona

Questo utilizza lo standard Python quine: memorizza il codice che vuoi eseguire in una variabile (come una stringa); includere un po 'di logica in quella stringa per stampare se stesso, tutto ciò che lo precede e tutto ciò che lo segue; quindi eseguire quella stringa.

Il codice che viene eseguito tramite la stringa s è il seguente.

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

La prima riga importa incondizionatamente il modulo atexit , che ci permetterà di registrare un gestore di uscita. Cercare di importare più volte lo stesso modulo non influisce in alcun modo sullo script. Quindi tenta di incrementare la variabile n , per tenere traccia di quante copie del codice sorgente sono state eseguite.

La seconda riga viene eseguita solo se la prima contiene un errore. Questo sarà il caso nella prima iterazione, poiché n è ancora indefinito. In questo caso, inizializziamo n come 1 e registriamo un lambda che esegue la magia reale.

Il gestore di uscita registrato

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

verrà chiamato subito prima della fine del programma. Il lambda stesso crea la stringa "s=%r;exec(s);"%s- %rcrea una rappresentazione di stringa dell'argomento a destra ( s ), che include tutto tra le singole citazioni e le citazioni stessi - allora itera sui suoi personaggi. Per ogni personaggio c , stampiamo semplicemente n copie di c . Passando c*ncome l'argomento di nome enddi printmezzi che nessun avanzamento riga verrà aggiunto.

CJam , 14 byte

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

Provalo online!

spiegazioni

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