Il tuo compito è creare un programma che stampi la propria fonte.

"Ehi, abbiamo già questa sfida, e tantissime varianti! Perché ne fai un'altra?" potresti chiedere, ma questo sarà uno dei più difficili (si spera, comunque).

Il tuo quine deve essere "indurito dalle mutazioni", il che significa che, anche quando uno dei suoi caratteri è duplicato, deve generare il codice sorgente del programma originale.

Ad esempio, se hai un quine (il seguente esempio non è scritto in nessuna lingua, è solo uno pseudocodice):

abcd

Questi programmi devono tutti produrre abcd:

aabcd
abbcd
abccd
abcdd

(In ciascuno di tali programmi, a, b, ce dsono ciascuno duplicato sul posto, il che significa che il carattere duplicato è stato posto direttamente dopo il carattere originale.)

Regole:

• Si applicano le regole standard di Quine.
• Un carattere multibyte conta come un carattere e, quando duplicato, non viene "diviso" nei suoi rispettivi byte.

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

> <> , 56 byte

^
.
+
8
f
0
o
a
o
~
:
?
~
:
?
:
-
*
4
8
:
^
^
}
*
3
d
'

Provalo online! o verifica tutte le mutazioni .

Come funziona il programma originale (obsoleto)

L'interprete inizia nella cella (0, 0) . ^imposta la direzione verso l' alto , quindi il puntatore dell'istruzione (IP) si avvolge attorno alla cella (0, 20) .

'attiva la modalità stringa: fino a quando non 'si incontra il successivo , tutti i caratteri sotto l'IP vengono inseriti nello stack. Lo stesso 'si ritrova dopo essersi avvolto, quindi spingiamo

d3*}^^:84*=?~oao0f.^

L'IP atterra a (0, 19) , andando ancora verso l'alto. L'esecuzione d3*}preme 13 = 0xd , quindi 3 , moltiplica entrambi i valori ( 39 / virgoletta singola ), quindi ruota la pila a destra. Questo lascia lo stack come segue.

'd3*}^^:84*=?~oao0f.^

Le prossime due istruzioni ( ^) non fanno nulla a questo punto.

:84*=duplica la parte superiore della pila, spinge 8 e 4 , li moltiplica ( 32 / spazio ), quindi verifica il carattere duplicato per l'uguaglianza con lo spazio . Per il programma inalterato, questo spingerà sempre 0 .

?salta l'istruzione successiva se la parte superiore della pila è falsa. Per il programma originale, lo è sempre, quindi ~viene sempre ignorato.

oaoapre e stampa la parte superiore della pila, spinge un 10 / avanzamento riga , quindi apre e stampa l' avanzamento riga .

Infine 0f.passa alla cella (0, 15) (il fondo ^), ricominciando con il personaggio successivo in pila.

Una volta che lo stack è vuoto, è stato stampato l'intero codice sorgente. :fallirà e il programma verrà chiuso.

Come funzionano i programmi mutati (obsoleti)

La duplicazione di qualsiasi carattere senza avanzamento riga prolungherà il programma solo in senso orizzontale. Poiché il programma viene eseguito verticalmente, queste istruzioni aggiuntive non verranno mai eseguite.

La duplicazione di qualsiasi avanzamento riga prima della parte inferiore ^sposta le celle (0, 14) e (0, 15) su (0, 15) e (0, 16) . 0f.passerà ora alla cella prima del minimo ^, che è anche a ^, quindi il programma non è influenzato dal turno.

Infine, qualsiasi carattere duplicato di avanzamento riga altererà anche la stringa. Le linee brevi sono riempite di spazi, quindi un 32 / spazio verrà inserito nella posizione dell'alimentazione di linea. 84*=spingerà 1 per lo spazio, quindi ?non salta la prossima istruzione. In questo caso, ~apre e scarta lo spazio , quindi invece overrà stampato il carattere sopra lo spazio .