Une quine 1-up est un programme qui ressemble beaucoup à une quine. La principale différence est qu'au lieu de s’imprimer une fois, lorsque n copies du programme sont concaténées, le résultat affiche le programme original n + 1 fois.

Exemple

Si votre programme est Abc123:

Abc123  ->  Abc123Abc123
Abc123Abc123  ->  Abc123Abc123Abc123
Abc123Abc123Abc123  -> Abc123Abc123Abc123Abc123

Défi

Votre défi est de créer la plus courte quine valide dans toutes les langues. Les règles habituelles de quine s'appliquent, vous ne pouvez donc pas:

• Soumettez le programme vide.
• Lire directement ou indirectement ¹ le code source.
• Utilisez les éléments intégrés de Quining.

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

^{1 Cela n'inclut pas l'utilisation d'une chaîne codée en dur ou d'un bloc de code dans le cadre de votre programme.}

GolfScript, 12 octets

{`'.~'+:n}.~

Essayez-le en ligne!

Explication

Cela combine les idées de la quine standard de GolfScript:

{'.~'}.~

Et ma quine récemment découverte :

":n`":n`

L’idée principale est d’utiliser à nouveau nce qui est imprimé implicitement à la fin du programme afin d’obtenir la copie supplémentaire de la quine. Étant donné que l’affectation de la variable ne change rien lorsqu’elle est répétée dans les copies suivantes, cela n’ajoute qu’une copie. Voici une ventilation du code:

{        # Standard quine framework. This pushes the block, duplicates it and runs the
         # second copy, such that it can process the first copy to create a quine.
  `      # Convert the block to its string representation.
  '.~'+  # Append the string '.~' to make a complete quine. This is simply left on the
         # stack to be printed at the end.
  :n     # Store the string in n such that one more copy is printed at the end.
}.~

GolfScript, 12 octets

{: ".~"][}.~

Essayez-le en ligne!

Comment fonctionne le code source

{: ".~"][}.~

{        }    Define and push a code block.
          .~  Push a copy and execute it.
 :            Save the code block in the space character.
              Every subsequent space will now execute the code block.
   ".~"       Push that string.
       ]      Wrap everything up to the last [ in an array.
        [     Set a new array marker.

Si le code source ci-dessus est exécuté une fois, la pile finira par

["" {: ".~"]} ".~"]

où la chaîne vide au début correspond à l'état initial de la pile (entrée vide).

Deux copies du code source laisseraient un état final de

["" {: ".~"]} ".~"] [{: ".~"]} ".~"]

trois copies un état final de

["" {: ".~"]} ".~"] [{: ".~"]} ".~"] [{: ".~"]} ".~"]

etc.

Qu'est-ce qui se passe ensuite

Après avoir exécuté le code source, l'interpréteur effectue les opérations suivantes.

1. Il enveloppe la pile entière dans un tableau et pousse ce tableau sur la pile.

   Pour deux copies du code source, la pile contient maintenant

   ["" {: ".~"][} ".~"] [{: ".~"][} ".~"] [["" {: ".~"][} ".~"] [{: ".~"][} ".~"]]
   

2. Il s'est exécuté putsavec l'intention d'imprimer la pile enveloppée, suivie d'un saut de ligne.

   putsest défini comme {print n print}suit:

   1. printimprime la copie enveloppée de la pile sans l'inspecter (c'est-à-dire sans la convertir en représentation sous forme de chaîne). Cela envoie

      {: ".~"][}.~{: ".~"][}.~
      

      (le code source) sur STDOUT et affiche la copie de pile au sommet de la pile.

      La pile contient maintenant

      ["" {: ".~"][} ".~"] [{: ".~"][} ".~"]
      

   2. exécute le bloc de code défini précédemment.

      :commence par sauvegarder [{: ".~"][} ".~"]dans le caractère espace, puis se ".~"pousse, ]enveloppe le ".~"dans un tableau et [définit un nouveau marqueur de tableau.

   3. n pousse une chaîne composée d'un seul saut de ligne.

      La pile contient maintenant

      ["" {: ".~"][} ".~"] [{: ".~"][} ".~"] [".~"] "\n"
      

   4. est exécuté une fois de plus. Cependant, il a été redéfini lorsque nous l'avons appelé pour la première fois et contient maintenant un tableau, pas un bloc de code.

      En fait, il pousse [{: ".~"][} ".~"], laissant la pile comme

      ["" {: ".~"][} ".~"] [{: ".~"][} ".~"] [".~"] "\n" [{: ".~"][} ".~"]
      

   5. Enfin, printimprime le dernier élément de la pile sans l'inspecter, puis l'envoyer

      {: ".~"][}.~
      

      STDOUT, 1-up le code source.

Javascript ES6 (REPL), 55 octets

var a=-~a;$=_=>`var a=-~a;$=${$};$();`.repeat(a+1);$();

2 octets sauvés grâce à @ user81655!

Explication

Voici le cadre standard de quine:

$=_=>`$=${$};$()`;$()

Vous devriez pouvoir voir ce cadre dans la soumission. Plus d'explications ci-dessous.

var a=-~a;

Ceci est le compteur, par défaut à 1. En gros, il nous dit combien il faut répéter le quine et incrémente en même temps.

$=_=>`var a=-~a;$=${$};$();`.repeat(a+1);$();

C'est la partie quine. Nous répétons essentiellement la chaîne quine par le compteur + 1. Les appels de fonction ultérieurs auront priorité sur la sortie.

CJam, 14 octets

{"_~"]-2>_o}_~

Essayez-le en ligne!

Comment ça marche

{"_~"]-2>_o}_~

{          }    Define a code block and push it on the stack.
            _~  Push and execute a copy of it.
 "_~"           Push that string.
     ]          Wrap the entire stack in an array.
      -2>       Discard all but the last two elements (block and string).
         _o     Push and print a copy of that array.

Une fois la dernière copie du programme exécutée, le tableau contenant le bloc et la chaîne est toujours sur la pile. Il est donc imprimé implicitement.

Groovy, 83 octets

s="s=%c%s%c;f={printf(s,34,s,34,10)};f()%cf()//";f={printf(s,34,s,34,10)};f()
f()//

Il y a une nouvelle ligne intégrée et aucune fin de ligne. Cela imprime:

s="s=%c%s%c;f={printf(s,34,s,34,10)};f()%cf()//";f={printf(s,34,s,34,10)};f()
f()//s="s=%c%s%c;f={printf(s,34,s,34,10)};f()%cf()//";f={printf(s,34,s,34,10)};f()
f()//

La fonction f()imprime une copie de la quine. Le programme initial l'appelle deux fois. La première ligne du code ajouté devient un commentaire et seul le deuxième appel à f()est exécuté.

Ruby, 43 octets

1;s="1;s=%p;$><<s%%s*n=2-0";$><<s%s*n=2-0

En soi, cela s'imprime 2-0ou les 2temps. Lorsqu'elle est concaténée à une autre copie de elle-même, l'instruction d'impression finale ressemble à une autre $><<s%s*n=2-01, ce qui signifie qu'elle ne sort qu'une seule fois ( 01étant l'octal 1). Ainsi, seule la copie finale de la chaîne est imprimée deux fois, les autres une fois.

L’affectation en ligne à nconsiste simplement à faire fonctionner correctement l’ordre des opérations; l'état n'est pas réellement transmis d'une copie à l'autre.

NodeJS, 63 61 60 55 octets

cela fonctionnera également en JavaScript (ES6) si vous considérez que plusieurs messages de la console sont séparés par des nouvelles lignes (pas de REPL requise)

2 octets sauvegardés grâce à @ dev-null

(f=_=>(t=_=>console.log(`(f=${f})()`)||(_=>t))(t()))()

notez qu'il y a une nouvelle ligne à la fin du code.

C’était intéressant, c’est l’un de mes favoris pour ce site à ce jour.

Je suis assez confiant que cela ne peut pas être joué beaucoup plus. (peut-être que la printfonction de SpiderMonkey ...)

Explication

//FIRST ITERATION
            console.log(`(f=${f})()`)                   //logs to the console a quine of the source code using function f's toString()
                                     ||                 //causes the expression to evaluate to the second part, since console.log's return value is falsy
                                       (_=>t)           //a function that returns function t when called
       t=_=>                                            //defines function t to be the code above. When called, t will log a quine and then return a function that returns t.
      (                                      )(t())     //call t twice. (one call is done via the t() as an ignored parameter) This will print the quine twice.
 f=_=>                                                  //define f as the above code.
(                                                  )()  //call function f with no arguments. this results in a function returning t. (the result of calling t once)
                                                        //this newline is to compensate for console.log's behavior of adding a newline to its output
//SECOND ITERATION
(                                                  )    //call the function that returns t that was returned from the first iteration. This expression will result in whatever that function returns, which is t.
 f=_=>(t=_=>console.log(`(f=${f})()`)||(_=>t))(t())     //this part evaluates to a function, which is passed as a parameter to the function that returns t, that ignores its parameter.
                                                    ()  //call whatever the last expression returned, which is the function t, with no parameters. This will print the quine once.
                                                        //this call will result in a function returning t, just like from the first iteration, so we can add on more iterations at will.

Ruby, 55 octets

n||=2;s="n||=2;s=%p;$><<(s%%s)*n;n=1;";$><<(s%s)*n;n=1;

Rien de très intéressant ici, c’est juste une quine de rubis normale avec un compteur.

JavaScript (ES6), 164 octets

console.log((`+String.fromCharCode(96)).repeat(window.a||(a=3,5)).slice(67,-14))
console.log((`+String.fromCharCode(96)).repeat(window.a||(a=3,5)).slice(67,-14))

Fonctionne dans n’importe quelle page de test ou console JS de Firefox, en supposant que l’espace entre deux messages de la console compte comme une nouvelle ligne.

Perl 6 , 58 53 octets

Merci à Jo King pour -5 octets.

<say "<$_>~~.EVAL for 0..!.++;">~~.EVAL for 0..!.++;

Basé sur la quine de Jo King .

Essayez-le en ligne!

Japt, 40 octets

Oo("+Q ²pT°?1:2 é4;POo("+Q ²pT°?1:2 é4;P

Testez-le en ligne! Explication à venir.

Y

Non concurrent, 6 octets

UCn*px

Y est un bandeau de tête que je possède depuis un moment et cela m'a inspiré pour l'écrire. Il est fait pour les défis dans lesquels la séquence est la clé, comme celle-ci. Le code est divisé en liens par des caractères "nœud". Dans ce cas, notre code est mis dans deux chaînes (à l'origine), le nœud étant C.

U  C  n* px
1  N    2

Uenregistre une chaîne transcendantale, c'est-à-dire une chaîne de liens. Il enregistre jusqu'à en rencontrer un autre U. Si un Un'est pas rencontré à la fin de la chaîne, il s'enroule autour. En outre, Uest inclus dans la chaîne par défaut. Après avoir enregistré la chaîne, nous passons au nœud C, ce qui nous déplace simplement vers le lien suivant.

npousse le nombre de chaînes. 2. Pour notre séquence de base, il s'agit de 2. Pour une séquence de Kchaînes, il existe des K+2chaînes, tout comme des Knœuds. *est string repittion. paffiche la pile entière (dans ce cas, une chaîne) et xtermine le programme.

Dans un texte:

UCn*px
U..... record that string
 C     next link
  n*   repeat that string twice.
    px print and terminate

UCn*pxUCn*pxUCn*px
U.....U            record string
 C                 next link
  n*               repeat that string four times (three Cs)
    px             print and terminate

Essayez-le ici!

Brachylog , 20 octets

⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅

Essayez-le en ligne!

Modifié à partir de cette quine.

⊥                       Fail,
 ∨                      or
                w       print
  "⊥∨~kgjw₃w₅"          "⊥∨~kgjw₃w₅"
                 ₃      formatted
              gj        with itself;
                 ₃w₅    print it again at the end of the program if this route succeeds.

Lorsque ceci est concaténé avec lui-même, chaque route sauf la dernière échoue et le programme passe à la suivante, les exécutant w₃et les retournant au-delà de w₅la dernière.

⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅

Essayez-le en ligne!

⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅

Essayez-le en ligne!

⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅

Essayez-le en ligne!