Un quine 1-up è un programma che è molto simile a un quine. La differenza principale è che invece di stampare una volta sola, quando vengono concatenate n copie del programma, il risultato stampa il programma originale n + 1 volte.

Esempio

Se il tuo programma è Abc123:

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

Sfida

La tua sfida è quella di creare il quine 1-up valido più breve in qualsiasi lingua. Si applicano le solite regole di quine, quindi non è possibile:

• Invia il programma vuoto.
• Leggere direttamente o indirettamente ¹ il codice sorgente.
• Usa i quining integrati.

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

^{1 Ciò non include l'uso di una stringa codificata o di un blocco di codice come parte del programma.}

GolfScript, 12 byte

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

Provalo online!

Spiegazione

Questo combina le idee del quine GolfScript standard:

{'.~'}.~

E il mio quine recentemente scoperto :

":n`":n`

L'idea principale è di nuovo da utilizzare, nche viene stampata implicitamente alla fine del programma al fine di ottenere la copia aggiuntiva del quine. Poiché l'assegnazione della variabile non cambia nulla quando viene ripetuta nelle copie successive, verrà aggiunta una sola copia. Ecco una ripartizione del codice:

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

{: ".~"][}.~

Provalo online!

Come funziona il codice sorgente

{: ".~"][}.~

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

Se il codice sorgente sopra viene eseguito una volta, lo stack finirà come

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

dove la stringa vuota all'inizio corrisponde allo stato iniziale dello stack (input vuoto).

Due copie del codice sorgente lascerebbero lo stato finale di

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

tre copie uno stato finale di

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

e così via.

Cosa succede dopo

Dopo aver eseguito il codice sorgente, l'interprete procede come segue.

1. Avvolge l'intero stack in un array e inserisce tale array nello stack.

   Per due copie del codice sorgente, lo stack ora contiene

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

2. È stato eseguito putscon l'intenzione di stampare la pila incartata, seguita da un avanzamento riga.

   putsè definito come {print n print}, quindi effettua le seguenti operazioni.

   1. printstampa la copia impilata della pila senza ispezionarla (ovvero senza convertirla nella sua rappresentazione in formato stringa). Questo invia

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

      (il codice sorgente) su STDOUT e apre la copia dello stack dalla parte superiore dello stack.

      Lo stack ora contiene

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

   2. esegue il blocco di codice che abbiamo definito in precedenza.

      :inizia salvando [{: ".~"][} ".~"]il carattere spazio, quindi si ".~"spinge da solo, ]avvolge ".~"un array e [imposta un nuovo marker di array.

   3. n spinge una stringa composta da un singolo avanzamento riga.

      Lo stack ora contiene

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

   4. viene eseguito ancora una volta. Tuttavia, è stato ridefinito quando lo abbiamo chiamato per la prima volta e ora contiene un array, non un blocco di codice.

      In effetti, spinge [{: ".~"][} ".~"], lasciando lo stack come

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

   5. Infine, printstampa l'elemento in pila più in alto senza ispezionarlo, inviandolo

      {: ".~"][}.~
      

      su STDOUT, aumentando di 1 il codice sorgente.

Javascript ES6 (REPL), 55 byte

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

2 byte salvati grazie a @ user81655!

Spiegazione

Ecco il framework quine standard:

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

Dovresti essere in grado di vedere questo framework all'interno dell'invio. Ulteriori spiegazioni di seguito.

var a=-~a;

Questo è il contatore, il cui valore predefinito è 1. Fondamentalmente, ci dice quanto ripetere la sequenza e gli incrementi contemporaneamente.

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

Questa è la parte quine. Sostanzialmente ripetiamo la stringa di quine per il contatore + 1. Le chiamate di funzione successive avranno la precedenza sull'output.

CJam, 14 byte

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

Provalo online!

Come funziona

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

Dopo che è stata eseguita l'ultima copia del programma, l'array che contiene il blocco e la stringa è ancora nello stack, quindi viene stampato implicitamente.

Groovy, 83 byte

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

C'è una nuova riga incorporata e senza trascinamento. Questo stampa:

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 funzione f()stampa una copia del quine. Il programma iniziale lo chiama due volte. La prima riga del codice allegato diventa un commento e f()viene eseguita solo la seconda chiamata a .

Rubino, 43 byte

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

Di per sé, questo si stampa da solo 2-0o 2volte. Se concatenato a un'altra copia di se stesso, appare la dichiarazione di stampa finale $><<s%s*n=2-01, il che significa che 01viene emessa una sola volta ( essendo ottale 1). Quindi solo la copia finale della stringa viene stampata due volte, le altre vengono stampate una volta.

L'assegnazione in linea a nè solo per far funzionare correttamente l'ordine delle operazioni; lo stato in realtà non viene passato da una copia alla successiva.

NodoJS, 63 61 60 55 byte

questo funzionerà anche in JavaScript (ES6) se si considerano più messaggi della console separati da newline (non è richiesta alcuna REPL)

Salvato 2 byte grazie a @ dev-null

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

nota che c'è una nuova riga alla fine del codice.

Questo è stato interessante, sicuramente uno dei miei preferiti per questo sito finora.

Sono abbastanza sicuro che questo non possa essere giocato a golf molto di più. (forse la printfunzione di SpiderMonkey ...)

Spiegazione

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

Rubino, 55 byte

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

Niente di molto interessante qui, è solo un normale rubino con un contatore.

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

Funziona in qualsiasi pagina di test JS o console in Firefox, supponendo che lo spazio tra i due messaggi della console sia considerato come una nuova riga.

Perl 6 , 58 53 byte

Grazie a Jo King per -5 byte.

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

Basato sul quine di Jo King .

Provalo online!

Japt, 40 byte

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

Provalo online! Spiegazione a venire.

Y

Non competitivo, 6 byte

UCn*px

Y è un copricapo che ho avuto per un po ', e questo mi ha ispirato a scriverlo. È fatto per le sfide in cui il sequenziamento è fondamentale, come questo. Il codice è diviso in collegamenti da caratteri "nodo". In questo caso, il nostro codice è inserito in due catene (originariamente), con il nodo essere C.

U  C  n* px
1  N    2

Uregistra una stringa trascendentale, cioè una stringa che si estende su collegamenti. Registra fino a quando non ne incontra un altro U. Se a Unon viene raggiunto alla fine della stringa, si avvolge. Inoltre, Uè incluso nella stringa per impostazione predefinita. Dopo aver registrato la stringa, si procede al nodo C, che ci sposta al collegamento successivo.

nspinge il numero di catene. Per il nostro caso di base, questo 2. Per una sequenza di Kcatene, ci sono K+2catene, in quanto vi sono Knodi. *è la replicazione delle stringhe. pstampa l'intero stack (in questo caso, una stringa) e xtermina il programma.

In un testo:

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

Provalo qui!

Brachylog , 20 byte

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

Provalo online!

Modificato da questo 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.

Quando questo è concatenato con se stesso, ogni percorso tranne l'ultimo fallisce e il programma passa a quello successivo, eseguendo ciascuno w₃e facendo un passo indietro rispetto a tutti w₅tranne l'ultimo.

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

Provalo online!

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

Provalo online!

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

Provalo online!