Concepto

Escriba un programa que genere código en su lenguaje de programación. Ese código, cuando se ejecuta, debe generar el programa original.

Reglas

• Como se trata de una trampa engañosa, puede leer el código fuente original.
• El primer programa de salida debe estar en el mismo idioma que el programa original.
• No puede generar una quine regular. Los dos programas deben ser diferentes.
• Se aplican lagunas estándar.
• Este es el código de golf, por lo que la respuesta más corta gana, sin embargo, no se seleccionará.

Bash + coreutils, 11 bytes

tr xy yx<$0

Esto imprime

tr yx xy<$0

Pruébalo en línea!

A su vez, eso imprime

tr xy yx<$0

Caracoles, 0 bytes

El segundo programa es

1

El primer programa cuenta el número de coincidencias del patrón vacío en la entrada vacía (que realmente tiene área 0, pero el patrón siempre se ejecuta al menos una vez como un truco para permitir que los programas decidan qué quieren imprimir en la entrada vacía). El segundo programa comienza con un cuantificador (como {1}en regex), que causa un error de análisis. Como el programa no se analiza correctamente, STDOUT es la cadena vacía.

7 , 2 bytes

7 usa un juego de caracteres de 3 bits, pero toma la entrada empaquetada en bytes (y según el meta, los idiomas con juegos de caracteres de subbytes se cuentan usando bytes para el archivo en el disco ). Aquí hay un xxdvolcado del programa:

00000000: 4cf4                                     L.

Al entregar este archivo al intérprete 7, generará el siguiente programa:

00000000: 4fa6 7f                                  O..

que a su vez generará el programa original nuevamente.

Entonces, ¿qué está pasando aquí? No hay lectura de fuente involucrada (en realidad, no creo que sea posible leer la fuente en 7), aunque podría decirse que el programa está engañando de otra manera; Déjame saber lo que piensas. Así es como funciona el programa. (Tenga en cuenta que cada comando 7 tiene dos variantes, algunas de las cuales no tienen nombres y no pueden aparecer en el programa original. Hay doce comandos en total, en seis pares. Estoy usando negrita para comandos activos, no negrita para pasivos comandos, y en los casos en que el comando activo no tiene nombre, lo estoy dando el mismo nombre que el comando pasiva correspondiente y confiando en la negrita de distinguir. en el caso en que los dos son llamados, por ejemplo, 7que es la variante activa de 1, cada comando tiene su propio nombre y la negrita es solo un resaltado de sintaxis).

231 7 23 Programa original, descomprimido en octal
231 empuje  237 en la pila
    23 empuje  23 sobre la pila
             (implícito) agregue una copia de la parte superior de la pila al programa
      2       Duplicar la parte superior de la pila (actualmente 23 )
        3      Salida de la parte superior de la pila, emerge el segundo elemento de la pila

En este punto, el intérprete 7 ve que la parte superior de la pila contiene comandos ( 2y 3) que no son representables, por lo que se escapa de la parte superior de la pila, produciendo 723(que es). El primer resultado del comando selecciona el formato de salida; en este caso, es el formato 7, "formatea la salida de la misma manera que el programa". Entonces, los comandos obtienen la salida empaquetada en bytes. Entonces el programa continúa:

231 7 23 23
             (implícito) agregue una copia de la parte superior de la pila al programa
        2     Duplicar la parte superior de la pila (actualmente 237 )
          3    Salida de la parte superior de la pila, desplegar el segundo elemento de la pila
           7   Empujar un elemento vacío sobre la pila

En este punto, no hay nada más que elementos de pila vacíos en la pila, por lo que el programa se cierra. Salimos 23antes. Si escapamos 237(y tenemos que hacerlo, porque contiene comandos no representables), obtenemos 7231. Eso obtiene salida directamente, haciendo la salida final del programa 237231(formateado de la misma manera que el programa, es decir, empaquetado en bytes). Eso es 4fa67f. (Se puede notar que el1 tenía sentido en términos de afectar el resultado; la única razón por la que existe es para hacer que los dos programas sean diferentes).

Correr 237231procede casi exactamente de la misma manera; la diferencia es que lo inútil se 1ejecuta justo después de la primera impresión (y el elemento vacío se elimina implícitamente la segunda vez que se alcanza el final actual del programa). Nuevamente, el resultado 231final se genera a sí mismo, el resultado 23final se genera a sí mismo precedido por un 7, y obtenemos231723 el programa original.

El observador podría notar que los dos programas, a pesar de tener la misma longitud en el octal "nativo" del lenguaje, tienen diferentes longitudes en el disco. Esto se debe a que un programa 7 puede rellenarse con un número arbitrario de 1 bit, y el formato empaquetado descarta el relleno final. Así es como ocurre la codificación:

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

En otras palabras, dos bytes 4C F4son suficientes para representar el programa, así que eso es todo lo que usé.

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

No hacer trampa:

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

Esto imprime:

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

que, cuando se ejecuta, imprime el programa original.

Lote, 14 bytes

@echo @type %0

Que cuando se ejecuta como cyclicquine.batsalidas

@type cyclicquine.bat

Que cuando se ejecuta genera el archivo por lotes original.

RProgN , 4 Bytes.

La comunidad parece considerar este tipo de cosas como una trampa engañosa , lo que satisface los criterios.

1
2

Con una nueva línea al final.

Esto imprime

2
1

Con una nueva línea al final, que imprime el primer código.

RProgN imprime el estallido de la pila, de arriba a abajo.

Pruébalo en línea!

Jolf, 6 bytes

1q_a_q

Cuando se ejecuta, esto genera:

q_a_q1

Que a su vez sale 1q_a_q.

Pruébalo aquí!

Explicación

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 bytes

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

Salidas:

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

-1 byte (@ETHProductions): use 0 en regex en lugar de \ d

Bash + Sed, 15 bytes

La misma idea que la respuesta de Dennis .

sed y/xz/zx/ $0

Bash, Cat y Rev, 19 16 bytes

rev $0 # 0$  ver

-3 gracias a @izabera

> <>, 16 bytes

"$r00gol?!;50.01

Pruébalo aquí!

Salidas

"$r00gol?!;50.10

Esta es una modificación de la que se proporciona aquí . No estoy seguro de si está haciendo trampa, lee el cuadro de código y lo genera.