Votre tâche consiste à créer un programme qui, lorsqu'il est exécuté, se retourne en sortie (c'est ce qu'on appelle une quine). Cependant, ce quine doit, lorsqu'il est copié nfois, renvoie le quine, mais avec chacun de ses caractères dupliqués à la place n, où nest un entier positif.

Si votre programme d'origine est 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.

Gardez à l'esprit que vous êtes autorisé à avoir des espaces dans votre programme "de base", mais ils sont comptés lors de "l'imbrication". Dites que votre programme est

Derp 
{newline}

(La nouvelle ligne signifie une nouvelle ligne de fin et il y a un espace supplémentaire après le Derp). Lorsqu'il est dupliqué pour devenir

Derp 
Derp 
{newline}

Vous devez sortir

DDeerrpp  
{newline}
{newline}

Gardez à l'esprit qu'il y a 2des espaces supplémentaires après le DDeerrpp.

Règles et spécifications:

• Votre programme doit contenir au moins deux caractères distincts (ce qui implique que votre code doit être d'au moins 2 octets).
• Les règles de quine standard s'appliquent.

C'est le code-golf , donc le code le plus court en octets gagne!

Fission , 6 octets

'!+OR"

Essayez-le en ligne! Essayez deux copies! Essayez trois!

Explication

Ceci est juste le quine standard de Fission . Il se trouve que cela fonctionne pour ce défi, car Fission a des points d'entrée explicites dans le programme. En particulier, en dupliquant le programme, on en ajoute un autre Rqui ajoute un autre atome (pointeur d'instruction). Étant donné que le code source est toroïdal, le code efficace en cours d'exécution ne change pas autrement - pour chaque atome, le code est toujours le même localement. Cependant, les atomes sont exécutés par étape de verrouillage, de sorte que les éléments qu'ils impriment sont entrelacés et nous obtenons une copie supplémentaire de chaque caractère dans la sortie.

Par souci d'exhaustivité, je vais juste répéter brièvement comment fonctionne le programme lui-même. Que nous répétions ou non le programme (par exemple '!+OR"'!+OR"'!+OR"), chaque atome voit le code suivant:

R"'!+OR"'!+O

Le "mode bascule l'impression de chaîne, de sorte que le programme commence par imprimer '!+ORdirectement sur STDOUT, qui est tout le quine sauf la citation. '!Définit ensuite la masse de l'atome sur le code de caractère de !, l' +incrémente, ce qui donne "et l' Oimprime tout en détruisant simultanément l'atome. Le programme se termine alors, car il n'y a plus d'atomes.

Python 2.7, 377 310 304 194 191 191 octets!

C'est mon premier golf, donc je ne m'attendais pas à ce qu'il soit trop bon. Mais je pensais que le concept dans la solution que j'ai trouvée était quelque peu drôle, donc je le poste quand même.

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

En effet, c'est une quine; vous pouvez l' essayer ici . Il abuse assez fort du module d'inspection.

Si nous essayons de l'exécuter avec le même code source x2, nous obtenons également la bonne sortie; vous pouvez l' essayer ici . x3, x4, etc. fonctionnent tous comme prévu.

Non golfé avec explication:

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 octets

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

Essayez-le en ligne!

Comment ça fonctionne

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

Que les blancs soient ma mort

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

Expliqué

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

Seigneur, je suis un monstre ...

Essayez-le en ligne!

Perl 5, 107 octets

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

Non golfé:

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

Essayez-le en ligne!

Python 3 , 122 121 112 112 octets

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

Essayez-le en ligne: un exemplaire | deux exemplaires | trois exemplaires | quatre exemplaires, avec vérification automatique

Comment ça fonctionne

Cela utilise le quine Python standard: Stockez le code que vous souhaitez exécuter dans une variable (sous forme de chaîne); inclure une certaine logique dans cette chaîne pour s'imprimer, tout ce qui précède et tout ce qui se trouve après; puis exécutez cette chaîne.

Le code qui est exécuté via la chaîne s est le suivant.

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

La première ligne importe inconditionnellement le module atexit , ce qui nous permettra d'enregistrer un gestionnaire de sortie. Essayer d'importer plusieurs fois le même module n'affecte en rien le script. Ensuite, il essaie d' incrémenter la variable n , pour garder une trace du nombre de copies du code source qui ont été exécutées.

La deuxième ligne n'est exécutée que si la première contient une erreur. Ce sera le cas lors de la première itération, car n n'est pas encore défini. Dans ce cas, nous initialisons n comme 1 et enregistrons un lambda qui effectue la magie réelle.

Le gestionnaire de sortie enregistré

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

sera appelé juste avant la fin du programme. Le lambda lui - même crée la chaîne "s=%r;exec(s);"%s- %rcrée une représentation de chaîne de l'argument droit ( s ), qui comprend tout entre les guillemets simples et les citations elles - mêmes - Itère puis sur ses personnages. Pour chaque caractère c , nous imprimons simplement n copies de c . Passer c*nl'argument nommé endà printsignifie qu'aucun saut de ligne ne sera ajouté.

CJam , 14 octets

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

Essayez-le en ligne!

Explications

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