Devi scrivere un programma che produrrà il codice sorgente che è

1. Più grande del programma originale (carattere saggio)
2. Stampa un altro programma più grande di se stesso quando viene eseguito (ovvero il nuovo programma è anche una risposta valida a questa sfida)

Questo è code-golf, quindi vince la risposta più breve.

GS2 (8636bd8e) , 0 byte

Questo stampa una sola nuova riga, che stampa due nuove righe, che stampa tre nuove righe, eccetera.

Provalo online!

H9 + : 1 carattere

9

Giusto. Un personaggio. Trasmette il testo a 99 bottiglie di birra , che è un programma valido. Tutti i dati estranei non contano, ma ci sono molti messaggi 9dentro.

L'output del programma emesso è il testo di 99 bottiglie di birra 59 volte.

Questa funzione indica il numero di volte in cui i testi vengono emessi se si eseguono i ntempi del programma (se il mio calcolo è corretto):

f(n) = 59n-1

GolfScript, 9 caratteri

{.'.~'}.~

Questo codice genera:

{.'.~'}{.'.~'}.~

che produce:

{.'.~'}{.'.~'}{.'.~'}.~

che produce:

{.'.~'}{.'.~'}{.'.~'}{.'.~'}.~

e così via.

Credo che questa sia la risposta più breve finora in un "vero" linguaggio di programmazione completo di Turing.

Spiegazione:

Fondamentalmente, il codice originale sopra è un "quine-layer": genera un quine normale seguito da se stesso.

In GolfScript, qualsiasi blocco di codice letterale (ad esempio {foo}), se lasciato indisturbato nello stack, è un quine. Di conseguenza, da solo, {.'.~'}emette semplicemente se stesso, proprio come farebbe qualsiasi altro blocco di codice.

Alla .~fine del codice prende l'ultimo blocco di codice nello stack, lo duplica ed esegue la copia. Quando eseguito, il codice .'.~'all'interno del blocco di codice duplica l'elemento più in alto nello stack (ovvero la copia di se stesso) e aggiunge la stringa .~.

Alla fine del programma, l'interprete GolfScript stringe ed emette tutto sullo stack, che, in questo caso, consiste in un {.'.~'}blocco in più rispetto all'input, più la stringa .~.

Bonus:

L'aggiunta di un ]prima del primo .(per raccogliere tutti i blocchi di codice nello stack in un array prima che vengano duplicati) lo fa crescere in modo esponenziale:

{].'.~'}.~

uscite:

{].'.~'}{].'.~'}.~

che produce:

{].'.~'}{].'.~'}{].'.~'}{].'.~'}.~

che produce:

{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}.~

e così via.

Caratteri Java 7: 0

Salva come file Blank.java. Se lo salvi come qualsiasi altro file, sostituisci qualsiasi istanza Blankcon il nome file appropriato.

Quindi, eseguire nella riga di comando tramite prima compilazione, quindi in esecuzione. Se la compilazione non riesce, interrompere.

Lo elenco come Java 7 perché potrebbe essere prodotto diversamente per le diverse versioni di Java.

Primi output (inviati a stderr):

Error: Could not find or load main class Blank

Blank.java:1: error: class, interface, or enum expected
Error: Could not find or load main class Blank
^
Blank.java:1: error: reached end of file while parsing
Error: Could not find or load main class Blank
                                              ^
2 errors

Blank.java:1: error: class, interface, or enum expected
Blank.java:1: error: class, interface, or enum expected
^
Blank.java:1: error:  expected
Blank.java:1: error: class, interface, or enum expected
                          ^
Blank.java:1: error:  expected
Blank.java:1: error: class, interface, or enum expected
                                     ^
Blank.java:1: error: as of release 5, 'enum' is a keyword, and may not be used as an identifier
Blank.java:1: error: class, interface, or enum expected
                                          ^
  (use -source 1.4 or lower to use 'enum' as an identifier)
Blank.java:1: error: = expected
Blank.java:1: error: class, interface, or enum expected
                                               ^
Blank.java:2: error:  expected
Error: Could not find or load main class Blank
     ^
Blank.java:2: error: ';' expected
Error: Could not find or load main class Blank
      ^
Blank.java:2: error: = expected
Error: Could not find or load main class Blank
                      ^
Blank.java:2: error: = expected
Error: Could not find or load main class Blank
                                   ^
Blank.java:2: error:  expected
Error: Could not find or load main class Blank
                                              ^
Blank.java:3: error: = expected
^
^
Blank.java:3: error: ';' expected
^
 ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
     ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
          ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
           ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
            ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
          ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
           ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
            ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
              ^
Blank.java:4: error: ';' expected
Blank.java:1: error: reached end of file while parsing
                   ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
                                 ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
                                        ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
                                         ^
Blank.java:4: error: ';' expected
Blank.java:1: error: reached end of file while parsing
                                              ^
Blank.java:5: error:  expected
Error: Could not find or load main class Blank
     ^
Blank.java:5: error: ';' expected
Error: Could not find or load main class Blank
      ^
Blank.java:5: error: = expected
Error: Could not find or load main class Blank
                      ^
Blank.java:5: error: = expected
Error: Could not find or load main class Blank
                                   ^
Blank.java:5: error:  expected
Error: Could not find or load main class Blank
                                              ^
Blank.java:6: error: = expected
                                              ^
                                              ^
Blank.java:6: error: ';' expected
                                              ^
                                               ^
Blank.java:7: error: reached end of file while parsing
2 errors
        ^
30 errors

HQ9 +, HQ9 ++ e simili, 2 caratteri

QQ

Questo è l'output:

QQQQ

Ruby 27

Una versione leggermente modificata di questo ( via ):

puts <<3*3,3
puts <<3*3,3
3

Il numero di volte in cui putsviene stampata la linea aumenta in modo esponenziale.

$ ruby quine.rb | ruby | ruby
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
3

$ ruby quine.rb | ruby | ruby | ruby | ruby | ruby | ruby | ruby | wc -l
    3283

Calcolo lambda - 29

Un semplice termine lambda

(λu.(u u)(u u))(λu.(u u)(u u))

Riducendo questo termine di una beta si ottengono riduzioni

((λu.(u u)(u u))(λu.(u u)(u u)))((λu.(u u)(u u))(λu.(u u)(u u)))

E così via e così via. È una semplice variante del classico (λu.u u)(λu.u u)che è un quine nel calcolo lambda, la doppia autoapplicazione qui significa che otteniamo il doppio dell'output.

SH script, 9

cat $0 $0

Cresce a ritmo esponenziale.

Eseguire come sh whatever.sho impostarlo come eseguibile.

La versione di Windows è qui .

dc 11

Abbastanza semplice:

6579792
dfP

La prima riga viene ripetuta una volta ogni generazione:

$ dc growing_quine.dc
6579792
6579792
dfP

$ dc growing_quine.dc | dc | dc 
6579792
6579792
6579792
6579792
dfP

L'ultima riga è composta dalle seguenti istruzioni: dduplica l'ultimo valore messo nello stack (6579792) (in modo da ottenere un'altra copia ogni volta che lo eseguiamo), fstampa l'intero stack (che è un gruppo dello stesso numero) e Pstampa il numero (6579792) come flusso di byte, che visualizza come dfP.

redcode (soluzione ricorsiva)

Questo è il codice del guerriero più semplice scrivibile in redcode , il famoso Imp:

MOV 0, 1

Quando eseguito, il codice scrive una copia della sua singola istruzione all'indirizzo successivo in memoria; quindi lo esegue, ecc.

Python 3 - 55

print(open(__file__).read())
f=lambda:print('f()')
f()

Questo potrebbe essere abbreviato sostituendo __ file__ con un singolo nome di file e salvando il file in quel modo, ma ho ritenuto che questa risposta fosse più nello spirito della domanda. Dopo una iterazione emette:

print(open(__file__).read())
f=lambda:print('f()')
f()
f()

Smalltalk, 125 61 57

La versione da golf sembra quasi illeggibile, quindi spiegherò prima (e userò identificatori reali).

Questa è una variante del metodo di auto-modifica del "modo più strano di produrre uno stack-overflow".

Il metodo stampa un messaggio di saluto e la sua fonte corrente (solo per la dimostrazione). Quindi, il codice viene modificato per generare una stringa più lunga e installato. Infine, il nuovo codice viene chiamato in modo ricorsivo.

Al fine di proteggere me stesso da una fuga immediata, consente all'utente di confermare in ogni ciclo.

compilare in Object:

eatMe_alice
   |msg mySource|

   mySource := thisContext method source.

   '**** Hello Alice' printCR.
   '  ---- my current code is:' printCR.
   mySource printCR.
   '  ---------------' printCR.

   (UserConfirmation confirm:'Again? ') ifTrue:[
       Object compile:
            (mySource
                copyReplaceString:'Hello ','Alice'
                withString:'Hello ','Alice !').
       self eatMe_alice
   ]

avviare lo spettacolo inviando "eatMe_alice" a qualsiasi Oggetto; zero farà:

nil eatMe_alice

Una buona variante è quella di non chiamare il nuovo codice in modo ricorsivo, ma invece iterativamente, svincolando lo stack di chiamate e rientrando nel nuovo metodo. Ciò ha il vantaggio di non provocare un'eccezione di ricorsione. Per fare ciò, sostituire la chiamata ricorsiva ("self eatMe_alice") con:

thisContext resend

Golf:

Ovviamente, la stampa e l'auto chiamata non sono state richieste, quindi il più breve (per il golf) è semplicemente quello di aggiungere un commento alla mia fonte e restituirlo. Come effetto collaterale, viene installato anche per la prossima chiamata ...

x|s|Object compile:(s:=thisContext method source,'""').^s

SH script, 12 8 7

Archivia un file con

sed p *

nella propria directory vuota ed eseguire da questa directory utilizzando sh [file]o impostare eseguibile.

Vecchia alternativa con 8 caratteri , ma non necessita di una propria directory. Archivia un file con

sed p $0

ed eseguire utilizzando sh [file]o impostare eseguibile.

Vecchia alternativa con 12 caratteri :

sed -i- p $0

Questo verrà effettivamente emesso nel file di programma stesso, ma non è stato specificato dove l'output. Si replica a un ritmo esponenziale.

JavaScript, 41 , 40 caratteri

function f(){console.log(f+"f(f())")}f()

La prima volta che lo esegui, si emette con un altro ;f()alla fine. Le successive esecuzioni dell'output determinano la stampa di ogni sorgente "input" due volte.

alertsarebbe più breve di console.logma non considero più dialoghi di avviso come "l'output" mentre sembra ragionevole chiamare più righe nella console come output.

J , 1 byte

'

Provalo online!

La citazione aperta dà, ovviamente, l'errore di citazione aperta:

|open quote
|   '
|   ^
|[-1] /home/runner/.code.tio

Si noti che, per la natura dell'interprete J, gli errori vengono stampati su STDOUT , non su STDERR.

Quando quanto sopra viene eseguito come codice, stampa:

|open quote
|   |   '
|       ^
|[-2] /home/runner/.code.tio

Poi

|open quote
|   |   |   '
|           ^
|[-2] /home/runner/.code.tio

e così via. Ogni volta che il codice viene eseguito, la seconda riga viene riempita a sinistra con quattro byte |   , soddisfacendo i requisiti di questa sfida.

J , variante quine corretta, 25 byte

echo,~'echo,:~(,quote)'''

Provalo online!

Outputs

echo,:~(,quote)'echo,:~(,quote)'

E poi si emette due volte, su linee separate:

echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'

poi

echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'

e così via.

Il primo output è una semplice variante di J quine standard . L'aggiunta si ,:~concatena verticalmente, dove l'array 2D risultante viene stampato come due righe della stessa stringa.

Windows .BAT, 25

@COPY %~nx0+%~nx0 CON>NUL

Cresce a ritmo esponenziale.

Versione SH equivalente qui .

reticolare, 11 byte, non competitivo

"'34'coo1o;

Questo è il framework quine standard, tranne che un extra 1viene stampato dopo ogni iterazione. Provalo online!

Prime uscite:

"'34'coo1o;
"'34'coo1o;1
"'34'coo1o;11
"'34'coo1o;111

Microscript II, 6 byte

La lingua non competitiva postdatizza la sfida.

"qp"qp

La prima iterazione aggiunge un extra qpalla fine e ogni iterazione successiva aggiunge una copia extra di questo programma originale all'inizio.

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.

EcmaScript 6 (51 byte):

(_=x=>'(_='+_+Array(x++).join(','+_)+')('+x+')')(2)

Produce una versione più lunga di se stesso, che può produrre una versione più lunga di se stesso, che può produrre una versione più lunga di se stesso, ecc ...

PHP, 38

<?echo fgets(fopen(__FILE__,'r')).';';

Aggiungerà un punto e virgola ad ogni esecuzione.

ECMAScript 6 (38 caratteri)

(f=_=>'(f='+f+')();(f='+f+')();')();

Quali uscite:

(f=_=>'(f='+f+')();(f='+f+')();')();(f=_=>'(f='+f+')();(f='+f+')();')();

modificare

Potresti fare (28 caratteri):

(f=_=>'(f='+f+')();'+f())();

Tuttavia, si ripeterà all'infinito e non restituirà mai nulla ... ma questo può essere risolto facendo qualcosa del genere (42 caratteri):

(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(3);

Che produrrà:

(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(3);(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(2);(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(1);

Lisp comune, 16 personaggi

(print `(or ,-))

Certo, è solo interattivo, ma essere in grado di fare riferimento all'attuale modulo di livello superiore è probabilmente il modo migliore per minimizzare un programma non banale che soddisfa le specifiche.

Ciò che sarebbe davvero interessante è ciò che esplode più velocemente. Forse qualcosa del genere

(print `(progn ,@(loop repeat (length -) collect -)))

Julia, 66 caratteri

x="print(\"x=\$(repr(x))\\n\$x;\"^2)";print("x=$(repr(x))\n$x;"^2)

Uscita (134 caratteri):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

Risultato dell'esecuzione del risultato (268 caratteri):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

risultato successivo (536 caratteri):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

Prossimo risultato (1072 caratteri):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

Spero che questo sia conforme alle regole.

Produce output più grandi e l'output stesso è un codice sorgente valido che produce di nuovo output più grandi.

05AB1E, 15 byte, non competitivo

0"DÐ34çý"DÐ34çý

Provalo online!

Stampa 0"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý,
che stampa 0"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý,
ecc.

Evoloop, rettangolo 9 × 9 (81 celle)

L' automa cellulare Evoloop incluso in Golly supporta schemi che si replicano in un modo "simile a quello di un quine". In particolare, questi schemi contengono ciascuno un "programma"; un modello si riproduce eseguendo prima il programma (che crea il "corpo" della figlia), quindi copiando il programma nella figlia.

Quanto sopra si applica al più famoso automa cellulare "Langton's Loops" e ad Evoloop, ma Evoloop ha una differenza interessante, che è che è facile creare un modello che cresce in ogni generazione successiva.

(Molto più interessante, secondo me, è il fatto che Evoloop sia un semplice automa cellulare che contiene schemi che si riproducono e si evolvono in modo molto realistico! Penso che gli unici automi cellulari conosciuti che fanno questo siano Evoloop e i suoi discendenti Un difetto di Evoloop, tuttavia, è che esiste un genoma "migliore" in particolare; l'evoluzione alla fine converge sempre in questo genoma.)

Ora, ci sono due carenze in questa presentazione. Uno è che non è chiaro quale sia l '"output" di un automa cellulare. Ma penso che un automa auto-riproducente sia "abbastanza vicino" per essere un quine; non è certo meno interessante! L'altro difetto è che questi schemi non creano semplicemente una singola copia di se stessi; ogni copia del modello originale tenta di creare infinite copie di se stessa, e queste copie finiscono per interagire tra loro in modo distruttivo. Quindi, penso di aver soddisfatto i requisiti di questa sfida nello spirito, ma non nella lettera.

Senza ulteriori indugi, il modello è:

022222220
270170172
212222202
202000212
272000272
212000202
202222212
271041032
022222250

Ecco di nuovo lo schema, in un formato che può essere copiato e incollato in Golly:

x = 9, y = 9, rule = Evoloop
.7B$BG.AG.AGB$BA5B.B$B.B3.BAB$BGB3.BGB$BAB3.B.B$B.5BAB$BGA.DA.CB$.6BE
!

Va bene, ma che aspetto ha? Sembra così:

Nell'animazione sopra, puoi vedere il modello iniziale creare una figlia più grande, che crea una nipote più grande, quindi una pronipote più grande, e infine una bisnipote ancora più grande che inizia a costruire una terza-ancora più grande- nipotina. Se seguissi questo schema per molto tempo, continuerebbe ad andare avanti così per sempre (o forse alla fine verrebbero superati dagli organismi evoluti, che sono in grado di riprodursi molto più velocemente; non ne sono sicuro).

LOTTO, 26

Inserisci questo codice in qualsiasi file .bat e continuerà ad essere eseguito (in un ciclo infinito) e anche il file crescerà.

echo echo %0 ^>^> %0 >> %0

PYG (6)

P(Q,Q)

Stampa il proprio codice sorgente, separato da newline. La seconda generazione sarebbe

P(Q,Q)
P(Q,Q)

e così via.

OLIO , 83 byte

0
0
1
1
1
4
1
11
4
1
11
1
2
2
1
12
18
10
18
1
32
22
1
18
26
4
26
8
18
11
6
17
4
26

Prima stampa due righe con uno zero in esse, quindi confronta ciascuna riga con la riga 1, se sono uguali (come nel caso in cui il file è esaurito), stampiamo ciò che è nella cella 26. L'output risultante apparirà come lo stesso, tranne con un aggiunto 33, che non fa nulla. La prossima volta verrà aggiunta un'altra riga e così via.

Aiuto, WarDoq! , 1 byte.

H

Stampe Hello, World!.

Altri caratteri oltre a H sono codici sorgente validi (e sicuri) (che stampano altre varianti di Hello World).