Scrivi un programma (o funzione) (chiamiamolo P1), che quando viene eseguito, genera un altro programma P2 della stessa lingua ed esattamente 1 byte più lungo di P1.

Il programma P2 quando eseguito, dovrebbe generare un terzo programma P3 che è 1 byte più lungo di P2. P3 deve generare un programma P4 che è un byte più lungo di P3, ecc. Lo stesso per P5, P6, ..., P∞.

La catena di programmi dovrebbe andare indefinitamente o in un posto dove l'interprete non può più gestire (ma deve rimanere come programma teoricamente valido nella lingua)

Regole

• Scappatoie standard vietate
• Tutti i programmi della catena dovrebbero essere in una lingua
• Non viene fornito alcun input. L'output passa allo stdout o al valore di ritorno della funzione
• Il programma deve terminare dopo un periodo di tempo. Un programma che interrompe la generazione dell'output dopo un certo intervallo di tempo ma non termina mai non si qualifica

Vince il programma più corto P1 in byte in ogni lingua!

JavaScript (ES6), 14 12 byte

-2 byte grazie a @Shaggy

f=_=>"f=_"+f

Test snippet

s=`f=_=>"f=_"+f`;

for(i=10;i--;s=eval(s)())
  o.innerText+=s+"\n";

<pre id=o></pre>

7 , 4 byte di ASCII

1603

Provalo online!

So che 7 non è normalmente codificato in ASCII, ma questa volta è una codifica più comoda, quindi stiamo aggiungendo 1 byte ad ogni esecuzione, non 3 bit.

Inoltre, non sono sicuro che questo valga come barare o no. (Di solito non è chiaro se un 7 quine stia tradendo o meno, dato che si trova a cavallo del limite in diversi modi.) Puoi argomentare decentemente che 0codifica il 6, ma in generale non è chiaro da dove provengano i caratteri risultanti "in 7 perché ha così tanti comportamenti impliciti, abbastanza bizzarri.

Questo programma si stampa con l' 1aggiunta e lo farà anche se si aggiungono un numero di messaggi 1. Ecco una traccia di debug commentata di 160311:

|| 160311      Initial data ||; initial program 160311
||7 60311      1 command = append 7 to data
|1 0311        6 command = escape from the last | onwards (7 escapes to 1)
|16e77         0311 commands = append 6e77 to data
|16e77 16e77   Implicit (program is empty): copy data past last | to program
|16e777 6e77   1 command = append 7 to data
71603111 e77   6 command = escape from the last | onwards
71603111 e77   e7 command = output in same encoding as the source

(Non sono |rimasti nel programma, quindi euscirà immediatamente dal programma come effetto collaterale, il che significa che gli ultimi 7non verranno mai eseguiti).

La confusione di base sulla provenienza di tutti i caratteri è che la maggior parte dei comandi in 7 produce solo dati durante l'esecuzione, quindi 6tenta di ricostruire una sequenza di comandi che produrrebbe il dato frammento di dati; questo spesso finisce vicino, ma non identico all'originale. (Ai fini del quining, normalmente si scrive un programma 7 in modo tale che il risultato sarà quasi lo stesso, normalmente diverso nei messaggi iniziali o finali 7.) Quindi, ad esempio, 1i dati diventano 716, che è il modo più semplice per aggiungere 1alla stringa di dati corrente. Inizialmente lo abbiamo prodotto con 16una sequenza di caratteri diversa (ma simile), eliminando in modo distruttivo uno dei|marcatori con cui sono iniziati i dati. (Suppongo che forse l'argomento migliore che questo non sia un quin letterale è che l'output è diverso dall'input!)

Haskell , 74 66 byte

MODIFICARE:

• -2 byte di H.PWiz utilizzando <>, quindi -6 spostando il (10*)<$>.

Questo ora utilizza il nuovo <>operatore gratuito ( Semigroupmoltiplicazione, richiede GHC 8.4 per funzionare senza un'importazione.)

main=putStr$fst<>show$(10*)<$>("main=putStr$fst<>show$(10*)<$>",1)

Provalo online! (Trucchi con un'importazione poiché TIO non ha ancora GHC 8.4.)

Come funziona

• main=putStr$ è boilerplate per generare il seguente valore di stringa.

• fst<>showè una funzione che accetta una tupla e restituisce una stringa composta dal primo elemento della tupla concatenata con la rappresentazione della stringa della tupla. ie

  (fst<>show)(s,t) = fst(s,t)<>show(s,t) = s++show(s,t)

• (10*)<$>moltiplica l' ultimo elemento della seguente tupla per 10, aggiungendo una cifra 0alla sua rappresentazione di stringa.

C (gcc) , 134 132 byte

Leggera rielaborazione del canonico C quine. Terribilmente lungo.

x;*s="x;*s=%c%s%c;main(i){for(i=__LINE__;i--;puts(&x));printf(s,34,s,34);}";main(i){for(i=__LINE__;i--;puts(&x));printf(s,34,s,34);}

Provalo online!

Fissione 2 , 7 byte

'!+OR!"

Provalo online!

Lo standard Fission quine , ma con un extra !che stampa un ulteriore 0x01 all'inizio del codice su ogni iterazione.

Pari / GP , 35 byte

(f=(x)->print1("(f="f")("1x")"))(1)

Provalo online!

Python 2 , 38 byte

s="print's=%r;exec s'%(s+'#')";exec s

Provalo online!

Brainfuck , 420 byte

->+++>>+++>+>++>+++>+>+>+++>>>>>>>>>>>>>>>>>>>>+>+>++>+++>++>>+++>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+>>+++>>+++>>>>>+++>+>>>>>>>>>++>+++>+++>+>>+++>+++>+>++>>+++>+>+++>+>++>+++>>>+>+>++>+++>+>+>>+++>>>>>>>+>+>>>+>+>++>+++>+++>+>>+++>>>+++>+>++>+++>++>>+>+>++>+++>+>+>>+++>>>>>+++>+>>>>>++>+++>+++>+>>+++>>>+++>+>+++>+>>+++>>+++>>++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++[[<++++++++++++++++>-]<+++++++++.<]>.

Provalo online!

Questa è una modifica del quin di BrainFuck "standard" , con un .alla fine che aggiusta un extra .ogni iterazione.

Il quine stesso codifica i caratteri Brainfuck come una pila di cifre esadecimali: in particolare, le cifre esadecimali di c-0x2b, che sono convenientemente le seguenti:

+: 0x00
-: 0x02
[: 0x30
]: 0x32
<: 0x11
>: 0x13
,: 0x01
.: 0x03

La codifica copre due frammenti di codice: >++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++spinge la codifica della codifica stessa, [[<++++++++++++++++>-]<+++++++++.<]cammina nello stack e stampa tutto.

Sporco , 9 byte

'"n[!]a!␛

Provalo online!

'   start and end a string literal
"   push a literal '
n   remove newlines
[!] print the string
a   push the alphabet
!   print the first character
␛   end the program

Se la lettura del codice sorgente è consentita:

Sporco , 8 byte

Q[!]W33!

Provalo online!

Ha spiegato:

Q   push the source code
[!] print each character
W   clear the now-empty stack
33! print an exclaimation mark

Potrebbe essere valido:

Sporco , 4 byte

Q[‼]

Provalo online!

Stampa il codice sorgente con una nuova riga finale.
(E un sacco di spazi, a causa di un bug. Funziona allo stesso modo senza di loro però.)

Nota che funziona solo nel set di caratteri nativo e non quando si utilizza il front-end UTF8, quindi per provarlo su TIO è necessario sostituire il carattere che emette tra []i messaggi ‼, che è l'equivalente UTF8 per ciò che sta stampando .

Java 8, 162 146 byte

v->{String s="v->{String s=%c%s%1$c+1;return s.format(s,34,s).replaceAll(%1$c1+$%1$c,%1$c%1$c);}"+1;return s.format(s,34,s).replaceAll("1+$","");}

Provalo online.
Prova il primo programma di output ; Prova il secondo programma di output ; Prova il terzo programma di output .

Spiegazione:

v->{                       // Method with empty unused parameter and String return-type
  String s="v->{String s=%c%s%1$c+1;return s.format(s,34,s).replaceAll(%1$c1+$%1$c,%1$c%1$c);}"
                           //  The unformatted source code
           +1;             //  Plus a random digit (1 in this case)
  return s.format(s,34,s)  //  Create the quine
          .replaceAll("1+$","");}
                           //  Then remove any trailing 1s

quine -part:

• Il String scontiene il codice sorgente non formattato.
• %sè usato per inserire questa stringa in se stessa con s.format(...).
• %c, %1$cE la 34vengono utilizzati per formattare le virgolette.
• s.format(s,34,s) mette tutto insieme

Parte sfida:

• +1 aggiunge un 1 al programma non formattato e formattato.
• .replaceAll("1+$","");}: Poiché vogliamo solo aumentare il conteggio dei byte del programma di uno anziché due, rimuoviamo tutti gli 1 finali prima di tornare.

> <> , 9 byte

#o<:}-1:"

Provalo online!

Variazione su un classico> <> quine, che aggiunge semplicemente un altro comando dupe per copiare #il fronte.

Perl 5 , 32 byte

$_=q{say"\$_=q{$_
};eval"};eval

Provalo online!

GolfScript , 9 byte

{'.~1'}.~

Provalo online!

CJam , 9 byte

{"_~1"}_~

Provalo online!

Sto pubblicando entrambe queste soluzioni nella stessa risposta, poiché sono solo banali variazioni l'una dell'altra e funzionano esattamente allo stesso modo. Sono entrambi basati sul quine GolfScript comune {'.~'}.~(o {"_~"}_~in CJam), che è descritto in modo più dettagliato, ad esempio in questa mia precedente risposta.

L'unica differenza è che questa variante aggiunge un 1byte alla fine del suo output. Come succede, qualsiasi stringa di 1s (o qualsiasi altro numero intero letterale senza zeri iniziali) è di per sé una banale quine sia in GolfScript che in CJam, quindi quelli già presenti alla fine del codice sopra saranno semplicemente copiati letteralmente nell'output. Poiché GolfScript (e CJam) utilizzano numeri interi di lunghezza arbitraria, questo funzionerà per programmi arbitrariamente lunghi, almeno finché il computer che esegue il codice ha memoria sufficiente per memorizzarlo.

Addetto , 76 72 61 byte

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]",Repr[x+sp]]

Provalo online!

Quine standard che aggiunge uno spazio alla fine di x ogni iterazione.

Prime iterazioni:

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]",Repr[x+sp]]

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]] ",Repr[x+sp]]

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]  ",Repr[x+sp]]

eccetera.

Attache, 72 byte

y:=1Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

Provalo online!

Questa è semplicemente una variazione del formato standard quine, con una variabile yimpostata su10*y dopo ogni iterazione

Le prime iterazioni:

y:=1Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

y:=10Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

y:=100Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

eccetera.

Swift 4 , 89 byte

let(a,b)=(";print(\"let(a,b)=\\((a,b+\"-\"))\"+a)", "");print("let(a,b)=\((a,b+"-"))"+a)

Include una nuova riga finale

Provalo online!

Haskell , 88 byte

main=putStr$snd(span(<'m')s)++show s;s='#':"main=putStr$snd(span(<'m')s)++show s;s='#':"

Provalo online! Cresce anteponendo #alla stringa di dati.

Stax , 20 18 byte

"34s+cTZL"34s+cTZL

Esegui ed esegui il debug

Genera uno spazio aggiuntivo prima della seconda virgoletta per ogni iterazione.

Spiegazione

Utilizza il programma "34s+cTZL "34s+cTZLper spiegare.

"34s+cTZL "34s+cTZL
"34s+cTZL "            String literal
           34s+        Prepend a double quote, Now the string is `"34s+cTZL `
               cT      Copy and trim trailing spaces
                 Z     Put a 0 under the top of stack
                       Stack now (from top to bottom): `["34s+cTZL,0,"34s+cTZL ]`
                  L    Collect all elements on stack, from bottom to top
                       Implicit output, 0 is converted to space.

Jstx , 4 byte

£↕♣:

Provalo online!

Incantesimi runici , 6 byte

"'<S@>

Provalo online!

Questo era strano. Tutto quello che dovevo fare era rimuovere un ~dalla quina originale trovata da Jo King .

Ogni corsa aggiuntiva ne aggiunge un'altra <alla fine, ad esempio:

"'<S@><<<<<<<<<

Tutto ciò non fa nulla.

Copia diretta di questa risposta su una sfida correlata. È solo successo che cresce già di 1 byte ogni iterazione (l'argomento forte per questa sfida è un duplicato di quello o viceversa).

Gelatina , 11 byte

“⁾;⁶;ØV” ṘV

Provalo online!

Meraviglia , 33 byte

f\ @(-> ol) ["f\ ";f;";f1";#0];f1

Una variante interessante sul quine normale che aggiunge un 1 dopo ogni iterazione.

Progressione:

f\ @(-> ol) ["f\ ";f;";f1";#0];f1
f\ @(-> ol) ["f\ ";f;";f1";#0];f11
f\ @(-> ol) ["f\ ";f;";f1";#0];f111
...

Spiegazione

f\ @                               #. Sets f to a function that does the following:
    (-> ol) [                      #.   Output each:
             "f\ ";                #.     String for declaration of f
                   f;              #.     Formatted representation of f's function
                     ";f1";        #.     String for call of f
                           #0      #.     Argument passed into f
                             ];f1  #. Call f with 1 as the argument

Una delle parti interessanti di questo quin è che Wonder può funzionare con numeri di precisione arbitraria, quindi la progressione non si interromperà dopo un certo numero di quelli.

ColdFusion, 277 byte

<cfset u=Chr(34)><cfset q="<cfset u=Chr(34)><cfset q=%s%s%s><cfoutput>%screateObject(%sjava%s,%sjava.lang.String%s).format(q,[u,q,u,Chr(35),u,u,u,u,Chr(35)])%s</cfoutput>
"><cfoutput>#createObject("java","java.lang.String").format(q,[u,q,u,Chr(35),u,u,u,u,Chr(35)])#</cfoutput>

Questa è una banale modifica del mio quine ColdFusion che aggiunge una nuova riga ogni volta che viene chiamato.

Testato localmente su lucee-express-5.2.6.60

Batch di Windows, 38 36 byte

echo|set/p"=q">q&copy/b/y %0+q %0
::

Questo codice crea un file chiamato "q", contenente la lettera "q", quindi lo aggiunge al file originale. Si noti che "::" è un alias per "rem" che non richiede uno spazio aggiuntivo.

Salvato 2 byte grazie a user3493001.

Gol> <> , 7 byte

":r2ssH

Provalo online! Provalo online !! Provalo online !!!

Questa è una semplice variazione del normale Gol> <> quine ma aggiunge una copia di Hogni volta che viene eseguito. Poiché il Hcomando interrompe il programma, ulteriori Halla fine non modifica il comportamento.

T-SQL , 175 byte

DECLARE @ VARCHAR(MAX)='DECLARE @ VARCHAR(MAX)=*SET @=TRIM(REPLACE(@,0x2a,CHAR(39)+@+CHAR(32)+CHAR(39)))PRINT @'SET @=TRIM(REPLACE(@,0x2a,CHAR(39)+@+CHAR(32)+CHAR(39)))PRINT @

Prima ho scritto un quine SQL, quindi l'ho modificato per aggiungere uno spazio extra (in qualche modo ispirato da questa risposta ).

Befunge-98 (PyFunge) , 22 19 byte

r:#,_ #;'D2/'<,,@;"

Provalo online!

Aggiunge un <prima dell'ultimo "ogni generazione.

C # (compilatore interattivo Visual C #) , 89 byte

var s="var s={0}{1}{0}+8;Write(s.Trim('8'),(char)34,s);"+8;Write(s.Trim('8'),(char)34,s);

Ispirato dalla risposta di Kevin Cruijssen.

Provalo online!