Concetto

Scrivi un programma che emette codice nel suo linguaggio di programmazione. Tale codice, una volta eseguito, deve generare il programma originale.

Regole

• Dato che si tratta di un cheat quine, puoi leggere il codice sorgente originale.
• Il primo programma di output deve essere nella stessa lingua del programma originale.
• Non è possibile produrre un quine regolare. I due programmi devono essere diversi.
• Si applicano scappatoie standard.
• Questo è code-golf, quindi vince la risposta più breve, tuttavia non verrà selezionata.

Bash + coreutils, 11 byte

tr xy yx<$0

Questo stampa

tr yx xy<$0

Provalo online!

A sua volta, ciò stampa

tr xy yx<$0

Lumache, 0 byte

Il secondo programma è

1

Il primo programma conta il numero di corrispondenze del modello vuoto sull'input vuoto (che in realtà ha l'area 0, ma il modello viene sempre eseguito almeno una volta come hack per consentire ai programmi di decidere cosa stampare su input vuoto). Il secondo programma inizia con un quantificatore (come {1}in regex), che causa un errore di analisi. Poiché il programma non analizza correttamente, STDOUT è la stringa vuota.

7 , 2 byte

7 utilizza un set di caratteri a 3 bit, ma accetta input impacchettato in byte (e in base a meta, le lingue con set di caratteri sub-byte vengono conteggiate utilizzando byte per il file su disco ). Ecco un xxddump del programma:

00000000: 4cf4                                     L.

Quando si dà questo file all'interprete 7, verrà emesso il seguente programma:

00000000: 4fa6 7f                                  O..

che a sua volta produrrà nuovamente il programma originale.

Quindi cosa sta succedendo qui? Non è prevista la lettura della fonte (in realtà, non credo sia possibile leggere la fonte in 7), anche se probabilmente il programma sta barando in un altro modo; Fatemi sapere cosa ne pensate. Ecco come funziona il programma. (Si noti che ogni comando 7 ha due varianti, alcune delle quali non hanno nomi e non possono apparire nel programma originale. Ci sono dodici comandi in totale, in sei coppie. Sto usando grassetto per comandi attivi, non grassetto per passivo comandi, e nei casi in cui il comando attivo non ha nome, gli sto assegnando lo stesso nome del comando passivo corrispondente e faccio affidamento sul grassetto per distinguere. Nel caso in cui entrambi siano denominati, ad esempio 7quale sia la variante attiva di 1, ogni comando ha il suo nome e il grassetto è solo l'evidenziazione della sintassi.)

231 7 23 Programma originale, non imballato in ottale
231 Spingi 237 sullo stack
    23 Spingere 23 sulla pila
             (implicito) aggiungi una copia della parte superiore dello stack al programma
      2       Duplicate top of stack (attualmente 23 )
        3      Output top of stack, pop pop stack element

A questo punto, l'interprete 7 vede che la parte superiore dello stack contiene comandi ( 2e 3) che non sono rappresentabili, quindi sfugge alla parte superiore dello stack, producendo 723(che è). Il primo comando output seleziona il formato di output; in questo caso, è formato 7, "formatta l'output nello stesso modo del programma". Quindi i comandi ottengono un output impacchettato in byte. Quindi il programma continua:

231 7 23 23
             (implicito) aggiungi una copia della parte superiore dello stack al programma
        2     Duplicate top of stack (attualmente 237 )
          3    Output top of stack, pop secondo stack element
           7   Spingete un elemento vuoto sulla pila

A questo punto, non ci sono altro che elementi dello stack vuoti nello stack, quindi il programma viene chiuso. Abbiamo prodotto 23prima. Se fuggiamo 237(e dobbiamo farlo, perché contiene comandi non rappresentabili), otteniamo 7231. Ciò ottiene direttamente l'output, producendo l'output finale del programma 237231(formattato nello stesso modo del programma, ovvero compresso in byte). Questo è 4fa67f. (Si può notare che 1era del tutto inutile in termini di effetti sull'output; l'unica ragione per cui è lì è rendere diversi i due programmi.)

La corsa 237231procede quasi esattamente allo stesso modo; la differenza è che l'inutile 1viene eseguito subito dopo la prima stampa (e l'elemento vuoto viene implicitamente eliminato la seconda volta che viene raggiunta la fine corrente del programma). Ancora una volta, 231finisce per emettersi, 23finisce per presentarsi preceduto da un 7, e otteniamo 231723, il programma originale.

L'osservatore potrebbe notare che i due programmi, nonostante abbiano la stessa lunghezza nell'ottale "nativo" della lingua, hanno lunghezze diverse sul disco. Questo perché un programma 7 può essere riempito con un numero arbitrario di 1 bit e il formato compresso scarta il riempimento finale. Ecco come avviene la codifica:

2  3  1  7  2  3
010011001111010011(1...)
4   c   f   4   padding

In altre parole, due byte 4C F4sono sufficienti per rappresentare il programma, quindi è tutto ciò che ho usato.

Python 3, 297 279 251 243 225 218 208 180 126 111 byte

Non barare:

A=''';print(("A="+("'"*3+A)*2).translate({65:66,66:65}))''';print(("A="+("'"*3+A)*2).translate({65:66,66:65}))

Questo stampa:

B=''';print(("B="+("'"*3+B)*2).translate({65:66,66:65}))''';print(("B="+("'"*3+B)*2).translate({65:66,66:65}))

che, una volta eseguito, stampa il programma originale.

Lotto, 14 byte

@echo @type %0

Che quando eseguito come cyclicquine.batoutput

@type cyclicquine.bat

Che quando eseguito genera il file batch originale.

RProgN , 4 byte.

La comunità sembra considerare questo genere di cose come una truffa cheat , che soddisfa così i criteri.

1
2

Con una nuova riga finale.

Questo stampa

2
1

Con una nuova riga finale, che stampa il primo codice.

RProgN stampa il popping dello stack, quindi dall'alto verso il basso.

Provalo online!

Jolf, 6 byte

1q_a_q

Quando eseguito, questo produce:

q_a_q1

Che a sua volta produce 1q_a_q.

Provalo qui!

Spiegazione

1q_a_q
1       the digit one (ignored)
 q      the source code (ignored)
     q  the source code
    _   reversed
   a    and outputted
 _      and reversed (ignored)

q_a_q1
q       the source code (ignored)
     1  the digit one (ignored)
    q   the source code
   _    reversed
  a     and outputted
 _      and reversed (ignored)

JavaScript (ES6), 69 60 59 byte

(_0=_=>console.log(`(_0=${_0})()`.replace(/0/g,n=>+!+n)))()

Uscite:

(_1=_=>console.log(`(_1=${_1})()`.replace(/1/g,n=>+!+n)))()

-1 byte (@ETHProductions): usa 0 in regex invece di \ d

Bash + Sed, 15 byte

Stessa idea della risposta di Dennis .

sed y/xz/zx/ $0

Bash, Cat e Rev, 19 16 byte

rev $0 # 0$  ver

-3 grazie a @izabera

> <>, 16 byte

"$r00gol?!;50.01

Provalo qui!

Uscite

"$r00gol?!;50.10

Questa è una modifica di quella fornita qui . Non sono sicuro che stia truffando, legge la codebox e la emette.