Fare una stampante intera versatile è bello e tutto, ma scrivere un singolo codice che stampa molti numeri diversi è ingombrante. Non sarebbe più facile creare uno script che produca un numero, ma ti dia anche un nuovo script per ottenere il numero successivo?

Sfida:

Scrivi un codice che genera un singolo numero intero Ne un codice eseguibile. Il codice successivo dovrebbe essere generato N+1e un codice in grado di produrre N+2. Continua questo percorso fino a raggiungere N = 15. (L'ultimo numero stampato dovrebbe essere 15).

Regole:

• Nessun input (supponiamo che l'input sia vuoto).
• Sono consentiti programma completo o funzione o altri formati convenienti.
• Il primo codice dovrebbe essere generato 1.
• Non è possibile generare zeri iniziali. Cioè non è possibile stampare 01per 1.
• L'output deve essere nel formato N, Code_for_N+1. Si noti che l'output è separato da una virgola e da un singolo spazio. Il codice per N+1non ha virgolette circostanti. N , Code_for_N+1non è accettato (spazio davanti alla virgola). Le nuove righe finali sono OK.
• Il primo carattere (i) dell'output deve essere il numero. (Nessuno spazio iniziale o ans = N).
• Il numero stampato non dovrebbe far parte del codice successivo (il codice può contenere questo numero, ma non puoi prendere il numero di output come parte del codice)
  • Esempio: L'uscita N=2può essere: 2, printer 2. In questo caso, printer 2è il codice per N=3. Non è possibile utilizzare l'intero output: 2, printer 2come codice per N=3.
• Gli script possono essere in diverse lingue
• I tipi di dati sono irrilevanti (il numero può essere una stringa), ma non può essere circondato da nulla (virgolette, parentesi ecc.).
• Se viene emesso un codice per N=15allora deve stampare STOP!(vedi bonus) o non stampare nulla (nemmeno uno spazio o una nuova riga).
  • Il codice per N=15non può andare in crash (ma l'output su STDERR è OK).
  • Sarai squalificato se il codice di output per N=15stampe 16o altro (tranne il caso bonus).
• Gli operatori Quine integrati non sono ammessi.
• L'accesso al file di origine tramite il file system non è consentito.

Bonus:

-10 byte se il codice che stampa 15 produce anche un codice che stampa " STOP!"

Esempi usando la sintassi di Python: (ovviamente, funzioneranno solo per gli interi selezionati, non da 1 a 15.)

N = 1
print "1, print 2"
1, print 2

---
N = 15
print 15
15

---
N = 15   (Qualifies for the -10 bytes bonus)
print "15, print 'STOP!'"
15, print 'STOP!'

print 'STOP!'
STOP!

----

N = 15   (Qualifies for the -10 bytes bonus)
print "15, disp('STOP!')"
15, disp('STOP!')        (disp('STOP!') outputs STOP! in MATLAB)

----
N = 15   (This one is not OK. The submission is disqualified)
print "15, print 16"
15, print 16

Si applicano le regole del golf standard! Il codice più piccolo (per N = 1) in byte vince!

Pyth + ///, 15 byte - 10 = 5

pPt`S15", STOP!

Questo stampa 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, STOP!in Pyth, togliendo range(1,15+1)e togliendo le parentesi di inizio e fine e stampandolo immediatamente seguito da ", STOP!".

I successivi quattordici programmi sono in ///, che genera direttamente tutti i programmi che non contengono /o \. Quindi il secondo programma

2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15

dà 2e il terzo programma 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15. Il penultimo programma viene 15, STOP!stampato 15, STOP!, quindi l'ultimo programma è giusto STOP!.

JavaScript, 131238-10 = 131228 byte

L'approccio ingenuo si è rivelato peggiore del previsto. Col senno di poi avrei dovuto aspettarmelo. Ma ho pensato di condividerlo comunque. Codice completo qui.

Idea: sfuggire e aggiungere in modo iterativo N-1, ...

alert("14,alert(\"15, alert(\\\"STOP!\\\")\")")

CJam, 26 25 24 byte

1{", "2$)@"_~"](_F<@*}_~

Provalo online.

I programmi successivi hanno semplicemente il primo numero incrementato. Questo esegue il programma 16 volte.

O con bonus per lo stesso punteggio:

1{", "\2$)_G<\@`+"_~"+"STOP!"`?}_~

Provalo online.

I programmi successivi hanno semplicemente il primo numero incrementato. Questo esegue il programma 16 volte.

Soluzione alternativa per il bonus:

1{", "\2$)Gmd@`+"_~"+"STOP!"`\?}_~

JavaScript (ES6), 62 61 byte - 10 bonus = 51 punti

_=>"1, "+(f=n=>`_=>"`+(n<16?n+`, "+(${f(n+1)})`:`STOP!"`))(2)

Spiegazione

Una soluzione che non legge il proprio codice sorgente e non è nemmeno ridicolmente lunga.

Il primo programma costruisce tutti gli altri 15 programmi e li nidifica l'uno dentro l'altro usando una funzione ricorsiva. Mi aggiro al problema della barra rovesciata annidando le funzioni stesse (che vengono quindi trasmesse alle stringhe durante l'output) anziché alle stringhe.

_=>
  "1, "                // print the first number
  +(f=n=>`_=>"`+(      // f = recursive function for printing program N
    n<16?              // for programs 2 - 15:
      n+`, "+(${       // add N to the output of the nested function
        f(n+1)         // nest the code of program N + 1
      })`
    :`STOP!"`          // program 16 just outputs "STOP!" for the bonus
  ))(2)                // start from program 2

Test

var nextProgram = '_=>"1, "+(f=n=>`_=>"`+(n<16?n+`, "+(${f(n+1)})`:`STOP!"`))(2)',
    n = 1;
while(nextProgram) {
  result.textContent += "Program " + n++ + ": " + nextProgram + "\n";
  var output = eval("(" + nextProgram + ")()");
  result.textContent += "   Output: " + output + "\n\n";
  var index = output.indexOf(",");
  nextProgram = index > 0 ? output.substr(index + 2) : null;
}

<pre id="result"></pre>

Matlab, 226 212 - 10 = 202 byte

Grazie a @StewieGriffin per alcuni byte =)

'awFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)

La prima parte è una stringa che rappresenta la seconda riga (sotto), il codice effettivo (appena spostato di 9). In Matlab, le stringhe sono matrici piene di caratteri, quindi puoi facilmente eseguire i turni semplicemente aggiungendo / sottraendo uno scalare. Quindi il programma stampa di nuovo la stessa stringa * di nuovo, più la stessa stringa ma spostata che risulta nel codice.

* Non del tutto: il primo byte è il contatore che deve essere aumentato in ogni iterazione.

Il trucco di quine con la corda è stato rubato senza vergogna da qui.

'awFjw|Dro)w1:26B?G:>DwF0\}xy*0Dnu|nDwFdw~v;|}{1w1:26B?2505)05<B5w1:24:5w1;Cnwm25<B5>B5w1;Cnwm26B500fDnwmDmr|y1w2';
n=ans;if n(1)-96>15;n='Stop!';else;n=[num2str(n(1)-96),', ',39,n(1)+1,n(2:end),39,59,n(2:end)-9,''];end;disp(n)

Ecco le ultime righe della sequenza copiate dalla console:

>> 'mwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
13, 'nwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
>> 'nwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
14, 'owFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
>> 'owFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
15, 'pwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
>> 'pwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
STOP!

JavaScript, 50 47 44 42 44 ^* byte

a=_=>(x=1)+(x<15?", a="+a:"").replace(x,x+1)

È una funzione che estrae il proprio corpo (solo a) e vi sostituisce. Se si ottiene che il corpo della funzione è una funzionalità integrata di JavaScript, sebbene non sia esplicitamente un operatore quine (se non è valido, verrà rimossa la risposta).

a=_=>(x=1)+(x<15?", a="+a:"").replace(x,x+1);
alert(a());

Nel caso in cui non funzioni correttamente incorporato lì (perché per me non funziona), puoi vedere un esempio lì .

^{* - sembra che lo snippet produca il risultato senza a=, rendendo impossibili ulteriori chiamate}

Python 2.7.10, 196 92-10 = 82 byte

Whee !!! È stato divertente. Molto più breve ora. : P

n=1;a='n=%d;a=%r;print n,a%%(n+1,a)if n!=15else"STOP!"';print n,a%(n+1,a)if n!=15else"STOP!"

Spiegazione:

Ho iniziato con questo:

a='a=%r;print a%%a';print a%a

Questo è solo un semplice quine. Questo è quello con un contatore aggiunto:

n=1;a='n=%d;a=%r;print n,a%%(n+1,a)';print n,a%(n+1,a)

nè una variabile contatore che viene stampata all'inizio. Quindi quando stampa la n=parte, sostituisce n+1la %d. Quindi da qui conterà all'infinito.

Ed ecco la versione finale. Aggiunge una clausola if per fermarsi alle 15 e stampa "STOP!" anche.

n=1;a='n=%d;a=%r;print n,a%%(n+1,a)if n!=15else"STOP!"';print n,a%(n+1,a)if n!=15else"STOP!"

Vecchio codice:

a= ['if num==15:print"STOP!!!";exit()','print num','print"a=",a','print"num=",num+1', 'for s in a:print s']
num= 1
print num
if num==15:print"STOP!!!";exit()
print"a=",a
print"num=",num+1
for s in a:print s

Non vincerò mai, ma divertente. : P Molto più breve ora, anche se non ho ancora alcuna possibilità. : P

PowerShell, (215-10) = 205 197 167 106 104 103 byte

$d='$c=(,1*{2}).count;$d={0}{1}{0};(("$c, $d"-f[char]39,$d,($c+1)),$c)[$c-eq15]';"1, $d"-f[char]39,$d,2

_{(Se il tuo unico strumento è PowerShell, ogni problema sembra un chiodo. Aspetta ...)}

In sostanza, iniziamo con un'impostazione $duguale a una stringa di dimensioni massime di quasi una quindicina del codice originale. Produce 1e quindi $dcon l'operatore di formato -fper compilare correttamente la {0}, {1}, {2}ins stand-, incrementando il {2}numero nella ,1*{2}sezione di uno ogni volta.

L' ,x*yoperazione in PowerShell crea un nuovo array di yelementi, ognuno dei quali è uguale a x. Ad esempio, ,2*3equivale a @(2,2,2).

Ciò significa che il primo output sarà 1, $c=(,1*2).length;$d=(etc...), quindi quando viene eseguito il secondo codice, $csarà uguale al conteggio dell'array @(1,1)o 2, ecc. Nota che $cnon viene utilizzato come variabile nel codice originale, solo nelle successive esecuzioni.

Si ferma quando stampa 15 semplicemente calcolando se è $cuguale 15e quindi indicizzando in un array, il 0 ° elemento è $c, $dcome descritto sopra, l'altro è giusto 15. Quindi, quando ha $c15 anni, verrà emesso 15e nient'altro. Non si qualifica per il bonus, perché "15, {0}STOP!{0}"è di 5 caratteri troppo lungo perché valga la pena di -10.

Richiede un terminale PowerShell di larghezza> ~ 150. O per rimuovere manualmente l'interruzione di riga aggiuntiva (che il terminale inserisce utile sull'involucro di output) quando si incolla il codice. Oppure per acquisire l'output in una variabile e quindi eseguirla nuovamente. Eccetera.

_{Modifica 1 - Salvati alcuni byte rimuovendo "STOP!" formulazione.
Modifica 2 - Durr, non usare .length ogni volta, basta chiamarlo una volta
Modifica 3 - Non deve essere un quine, quindi la corsa iniziale può essere molto più breve
Modifica 4 - Modificato dall'uso delle stringhe a matrici da calcolare $c, che hanno salvato due byte. Sono abbastanza sicuro che sia quasi ottimale per questo approccio.
Modifica 5: salvato un altro byte contando direttamente l'uguaglianza piuttosto che il modding}

JavaScript, 79-10 = 69 byte

s='STOP!';for(i=15;i;){s=i--+',alert("'+s.replace(/[\\"]/g,"\\$&")+'")'};alert(s)

Senza usare Function.prototype.toStringin alcun modo.

Befunge, 57 - 10 = 47 byte

1:'!`'#*j:.',,1+:9`''*'0++,1#;:0g:48*`j@,1+;"!POTS",,,,,@

Questo è fantastico. Provalo qui .

Lotto, 73 + 5-10 = 68 byte

@set a=STOP!
@for /l %%a in (15,-1,1)do @set a=%%a, @echo !a!
@echo %a%

Richiede CMD /V:ONquindi ho aggiunto 5 byte per quello.

Python 2.7, 107 caratteri

Usando la ricorsione e non scrivendo un quine, ho pensato di poter risparmiare molto, il che è vero, ma non abbastanza buono. Sebbene non sia un vincitore, penso che l'approccio sia divertente da condividere.

Ho iniziato inventando una stringa per N = 4, sfuggendo ai caratteri \e ".

print "1, print \"2, print \\\"3, print \\\\\\\"4, print \\\\\\\\\\\\\\\"STOP!\\\\\\\\\\\\\\\"\\\\\\\"\\\"\""

Quindi ho creato una funzione lambda che crea questa stringa, basata su un indice di avvio e un indice di arresto, utilizzando la ricorsione. Questo è:

l=lambda n,m:str(n)+", print "+"\\"*(2**(n-1)-1)+"\""+l(n+1,m)+"\\"*(2**(n-1)-1)+"\"" if n<m else "STOP!"

Usalo in questo modo:

print l(1,15)

Output: [32902 caratteri, troppo lungo da gestire]

Quindi, sembra che il mio approccio alla complessità di kolmogorov non abbia avuto successo ;-)

SMBF , 28 byte

\x10rappresenta un byte letterale (valore decimale 16). L'intero viene emesso come intero (byte). Quindi il primo output di caratteri è \x01. Il programma quindi stampa ",". Quando stampa la propria fonte, all'inizio ne stampa un extra +.

+.<-<<.>.>[[<]>.[.>]<[-]], \x10

Spiegazione:

+.                                  Increment number and print
  <-                                Pre-decrement loop counter
    <<.>.>                          Print comma and space from own source
          [             ]           Only execute if loop counter != 0
           [<]>.                    Move to left of source, then print `+`
                [.>]                Print entire source.
                    <[-]            Zero out the loop counter so this program halts.
                         , \x10     The comma, space, and loop counter used earlier.
                                    Input is empty, so `,` doesn't do anything.

Si noti che non è possibile eseguirlo in un interprete standard perché richiede un valore letterale esadecimale nell'input. È inoltre necessario un terminale speciale affinché l'uscita esadecimale funzioni correttamente.

Bash, 78 74 73 - 10 = 63 byte (Esempio, impossibile vincere)

p='if(($((++a>15))));then unset a p;fi;echo ${a-STOP\!}${p+, $p}';eval $p

Arrivando in ritardo, ma ho visto che Bash non era stato provato, quindi ho provato. Prima sfida del Golfo e puzzle simile a un quine. Sono divertenti!

Spiegazione:

Questo funziona perché apassi da 1 a 15 ed è quindi unsetinsieme a p. Lo script (memorizzato in p) li stampa entrambi se sono sete "STOP!" altrimenti. Inizialmente unset aè set0 perché appare in un'espansione aritmetica.

𝔼𝕊𝕄𝕚𝕟, 30 caratteri / 47 byte (non competitivo)

⟮a=1)+(a<ḏ?⬬+ⒸⅩ222+ᶈ0:⬯)ē(a,⧺a

Try it here (Firefox only).

Finalmente ho trovato un buon vecchio quine per 𝔼𝕊𝕄𝕚𝕟.

Spiegazione

Ecco il vero quine che ho usato: ⟮ⒸⅩ222+ᶈ0

Lo vedi nella mia risposta? Spero che sarete tutti in grado di espandersi da lì.

Keg + PHP, 19-10 = 10 byte

ï_(. \,,,)\!POTS(,

Conta da 1 a 15 e poi si ferma. TIO

Fusto, 13 byte

ï_(. \,,,).