Eine 1-up-Quine ist ein Programm, das einer Quine sehr ähnlich ist. Der einzige wesentliche Unterschied besteht darin, dass das Ergebnis n + 1- mal das ursprüngliche Programm druckt , anstatt sich selbst einmal zu drucken, wenn n Kopien des Programms verkettet werden .

Beispiel

Wenn Ihr Programm ist Abc123:

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

Herausforderung

Ihre Herausforderung besteht darin, das kürzeste gültige 1-up-Quine in jeder Sprache zu erstellen. Es gelten die üblichen Quine-Regeln. Sie dürfen also nicht:

• Senden Sie das leere Programm.
• Lesen Sie direkt oder indirekt ¹ den Quellcode.
• Verwenden Sie Quining-Built-Ins.

Das ist Code-Golf, also gewinnt der kürzeste Code in Bytes.

^{1 Dies beinhaltet nicht die Verwendung einer fest codierten Zeichenfolge oder eines Codeblocks als Teil Ihres Programms.}

GolfScript, 12 Bytes

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

Probieren Sie es online!

Erläuterung

Dies kombiniert Ideen aus dem Standard GolfScript Quine:

{'.~'}.~

Und meine kürzlich entdeckte Quine :

":n`":n`

Die Hauptidee ist wieder, ndie implizit am Ende des Programms gedruckt wird, um die zusätzliche Kopie des Quine zu erhalten. Da die Zuweisung der Variablen nichts ändert, wenn sie in nachfolgenden Kopien erneut ausgeführt wird, wird nur eine Kopie hinzugefügt. Hier ist eine Aufschlüsselung des Codes:

{        # 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 Bytes

{: ".~"][}.~

Probieren Sie es online!

Wie der Quellcode funktioniert

{: ".~"][}.~

{        }    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.

Wenn der obige Quellcode einmal ausgeführt wird, endet der Stack als

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

Dabei entspricht die leere Zeichenfolge am Anfang dem Anfangszustand des Stapels (leere Eingabe).

Zwei Kopien des Quellcodes würden einen endgültigen Zustand von

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

drei Kopien ein Endzustand von

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

und so weiter.

Was passiert als nächstes

Nach dem Ausführen des Quellcodes führt der Interpreter die folgenden Schritte aus.

1. Es umschließt den gesamten Stapel in einem Array und verschiebt dieses Array auf den Stapel.

   Für zwei Kopien des Quellcodes enthält der Stapel jetzt

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

2. Es wurde putsmit der Absicht ausgeführt, den verpackten Stapel zu drucken, gefolgt von einem Zeilenvorschub.

   putsist definiert als {print n print}, so macht es das Folgende.

   1. printdruckt die eingepackte Kopie des Stapels, ohne ihn zu untersuchen (dh ohne ihn in seine Zeichenfolgendarstellung zu konvertieren). Das schickt

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

      (der Quellcode) zu STDOUT und fügt die Stapelkopie oben im Stapel ein.

      Der Stapel enthält jetzt

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

   2. führt den zuvor definierten Codeblock aus.

      :Beginnt mit dem Speichern [{: ".~"][} ".~"]des Leerzeichens, verschiebt sich dann ".~"selbst, ]umschließt ".~"ein Array und [setzt einen neuen Array-Marker.

   3. n Drückt eine Zeichenkette, die aus einem einzelnen Zeilenvorschub besteht.

      Der Stapel enthält jetzt

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

   4. wird noch einmal ausgeführt. Es wurde jedoch beim ersten Aufruf neu definiert und enthält nun ein Array, keinen Codeblock.

      Tatsächlich drückt es [{: ".~"][} ".~"]und lässt den Stapel unverändert

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

   5. Zum Schluss wird printdas oberste Stapelelement gedruckt, ohne es zu untersuchen, und gesendet

      {: ".~"][}.~
      

      zu STDOUT, 1-up den Quellcode.

Javascript ES6 (REPL), 55 Byte

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

2 Bytes gespart dank @ user81655!

Erläuterung

Hier ist das Standard-Quine-Framework:

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

Sie sollten diesen Rahmen in der Übermittlung sehen können. Weitere Erklärung unten.

var a=-~a;

Dies ist der Zähler, der standardmäßig auf 1 eingestellt ist. Im Grunde sagt er uns, wie viel Quine und Inkremente gleichzeitig wiederholt werden müssen.

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

Dies ist der entscheidende Teil. Wir wiederholen den Quine-String im Wesentlichen um den Zähler + 1. Nachfolgende Funktionsaufrufe überschreiben die Ausgabe.

CJam, 14 Bytes

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

Probieren Sie es online!

Wie es funktioniert

{"_~"]-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.

Nachdem die letzte Kopie des Programms ausgeführt wurde, befindet sich das Array, das den Block und die Zeichenfolge enthält, noch im Stapel, sodass es implizit gedruckt wird.

Groovy, 83 Bytes

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

Es gibt eine eingebettete und keine nachgestellte Newline. Dies druckt:

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

Die Funktion f()druckt eine Kopie des Quines. Das ursprüngliche Programm ruft es zweimal auf. Die erste Zeile des angehängten Codes wird zu einem Kommentar und nur der zweite Aufruf von f()wird ausgeführt.

Ruby, 43 Bytes

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

Dies druckt sich selbst 2-0oder 2mal. Wenn die endgültige Druckanweisung mit einer anderen Kopie von sich selbst verknüpft ist, sieht sie so aus $><<s%s*n=2-01, dass sie sich nur einmal ausgibt ( 01als Oktal 1). Es wird also nur die letzte Kopie der Zeichenfolge zweimal gedruckt, die anderen werden einmal gedruckt.

Die Inline-Zuweisung zu ndient nur dazu, die Reihenfolge der Vorgänge korrekt zu bestimmen. Zustand wird nicht tatsächlich von einer Kopie zur nächsten weitergegeben.

NodeJS, 63 61 60 55 Bytes

Dies funktioniert auch in JavaScript (ES6), wenn Sie davon ausgehen, dass mehrere Konsolenmeldungen durch Zeilenumbrüche getrennt sind (kein REPL erforderlich).

2 Bytes dank @ dev-null gespeichert

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

Beachten Sie, dass sich am Ende des Codes eine neue Zeile befindet.

Dies war ein interessanter, definitiv einer meiner Favoriten für diese Site.

Ich bin ziemlich zuversichtlich, dass man nicht mehr viel Golf spielen kann. (Vielleicht SpiderMonkeys printFunktion ...)

Erläuterung

//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 Bytes

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

Hier ist nichts sehr Interessantes, es ist nur eine normale Rubin-Quine mit einer Theke.

JavaScript (ES6), 164 Byte

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

Funktioniert auf jeder JS-Testseite oder -Konsole in Firefox, vorausgesetzt, der Abstand zwischen zwei Konsolenmeldungen wird als Zeilenumbruch gewertet.

Perl 6 , 58 53 Bytes

Danke an Jo King für -5 Bytes.

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

Basierend auf Jo Kings Quine .

Probieren Sie es online!

Japt, 40 Bytes

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

Testen Sie es online! Erklärung zu kommen.

Y.

Nicht konkurrierend, 6 Bytes

UCn*px

Y ist eine Kopfkanone, die ich seit einiger Zeit besitze, und das hat mich dazu inspiriert, sie zu schreiben. Es ist für Herausforderungen gedacht, bei denen Sequenzierung eine Schlüsselrolle spielt. Der Code ist durch "Knoten" -Zeichen in Verknüpfungen unterteilt. In diesem Fall wird unser Code (ursprünglich) in zwei Ketten eingeteilt, wobei der Knoten ist C.

U  C  n* px
1  N    2

Uzeichnet eine transzendentale Zeichenfolge auf, dh eine, die sich über Links erstreckt. Es zeichnet auf, bis es ein anderes trifft U. Wenn a Uam Ende der Zeichenfolge nicht erfüllt ist, wird es umgebrochen. Ist Uauch standardmäßig in der Zeichenfolge enthalten. Nach dem Aufzeichnen des Strings fahren wir mit dem Knoten fort C, der uns nur zum nächsten Link bewegt.

ndrückt die Anzahl der Ketten. Für unseren Basisfall ist dies 2. Für eine Folge von KKetten gibt es K+2Ketten, wie es KKnoten gibt. *ist Zeichenkettenwiederholung. pdruckt den gesamten Stapel (in diesem Fall einen String) und xbeendet das Programm.

In einem Text:

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

Probieren Sie es hier aus!

Brachylog , 20 Bytes

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

Probieren Sie es online!

Geändert von diesem 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.

Wenn dies mit sich selbst verknüpft ist, schlägt jede Route mit Ausnahme der letzten fehl und das Programm fährt mit der nächsten fort, wobei jede Route ausgeführt w₃und jede mit w₅Ausnahme der allerletzten zurückverfolgt wird.

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

Probieren Sie es online!

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

Probieren Sie es online!

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

Probieren Sie es online!