Conceito

Escreva um programa que produz código na sua linguagem de programação. Esse código, quando executado, deve gerar o programa original.

Regras

• Como esta é uma trapaça, você pode ler o código fonte original.
• O primeiro programa de saída deve estar no mesmo idioma que o programa original.
• Você não pode produzir uma solução regular. Os dois programas devem ser diferentes.
• Aplicam-se brechas padrão.
• Este é o código-golfe, por isso a resposta mais curta vence, mas não será selecionada.

Bash + coreutils, 11 bytes

tr xy yx<$0

Isso imprime

tr yx xy<$0

Experimente online!

Por sua vez, isso imprime

tr xy yx<$0

Caracóis, 0 bytes

O segundo programa é

1 1

O primeiro programa conta o número de correspondências do padrão vazio na entrada vazia (que realmente possui a área 0, mas o padrão é sempre executado pelo menos uma vez como um hack para permitir que os programas decidam o que desejam imprimir na entrada vazia). O segundo programa começa com um quantificador (como {1}no regex), que causa um erro de análise. Como o programa não analisa com êxito, STDOUT é a sequência vazia.

7 , 2 bytes

7 usa um conjunto de caracteres de 3 bits, mas recebe a entrada compactada em bytes (e de acordo com a meta, os idiomas com conjuntos de caracteres de sub bytes são contados usando bytes para o arquivo no disco ). Aqui está um xxddespejo do programa:

00000000: 4cf4                                     L.

Ao fornecer esse arquivo para o 7 intérprete, ele produzirá o seguinte programa:

00000000: 4fa6 7f                                  O..

que, por sua vez, produzirá o programa original novamente.

Então, o que está acontecendo aqui? Não há leitura da fonte envolvida (na verdade, não acho que seja possível ler a fonte no 7), embora o programa esteja enganando de outra maneira; Diz-me o que pensas. Veja como o programa funciona. (Observe que cada comando 7 tem duas variantes, algumas das quais não têm nomes e não podem aparecer no programa original. Existem doze comandos no total, em seis pares. Estou usando negrito para comandos ativos, não-negrito para passivo comandos, e nos casos em que o comando ativo não tem nome, eu estou dando o mesmo nome que o comando passivo correspondente e confiando no negrito para distinguir.No caso em que ambos são nomeados, por exemplo, 7qual é a variante ativa de 1, cada comando recebe seu próprio nome e o negrito é apenas o destaque da sintaxe.)

231 7 23 Programa original, descompactado em octal
231 Empurre 237 para a pilha
    23 Empurre 23 para a pilha
             (implícito) anexa uma cópia da parte superior da pilha ao programa
      2       Parte superior duplicada da pilha (atualmente 23 )
        3      Parte superior da saída, segundo elemento pop da pilha

Nesse ponto, o 7 intérprete vê que o topo da pilha contém comandos ( 2e 3) que não são representáveis; portanto, ele escapa do topo da pilha, produzindo 723(o que é). A primeira saída de comando seleciona o formato de saída; neste caso, é o formato 7, "formate a saída da mesma maneira que o programa". Portanto, os comandos são compactados em bytes. Então o programa continua:

231 7 23 23
             (implícito) anexa uma cópia da parte superior da pilha ao programa
        2     Parte superior da pilha duplicada (atualmente 237 )
          3    Parte superior da pilha, pop o segundo elemento da pilha
           7   Empurre um elemento vazio na pilha

Neste ponto, não há nada além de elementos de pilha vazios na pilha, portanto o programa é encerrado. Nós produzimos 23mais cedo. Se escaparmos 237(e precisarmos, porque ele contém comandos irrepresentáveis), obtemos 7231. Isso obtém a saída diretamente, produzindo a saída final do programa 237231(formatada da mesma maneira que o programa, ou seja, compactada em bytes). É isso 4fa67f. (Pode-se notar que isso 1foi totalmente inútil em termos de afetar a saída; a única razão para existir é fazer os dois programas diferentes.)

A corrida 237231ocorre quase exatamente da mesma maneira; a diferença é que o inútil 1é executado logo após a primeira impressão (e o elemento vazio é excluído implicitamente na segunda vez que o final do programa é atingido). Mais uma vez, as 231extremidades até a saída de si, as 23extremidades até a saída de si precedido por um 7, e nós temos 231723, o programa original.

O observador pode observar que os dois programas, apesar de terem o mesmo comprimento no octal "nativo" do idioma, têm comprimentos diferentes no disco. Isso ocorre porque um programa 7 pode ser preenchido com um número arbitrário de 1 bits, e o formato compactado descarta o preenchimento à direita. Veja como a codificação acontece:

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

Em outras palavras, dois bytes, 4C F4são suficientes para representar o programa, então foi tudo o que usei.

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

Não trapaça:

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

Isso imprime:

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

que, quando executado, imprime o programa original.

Lote, 14 bytes

@echo @type %0

Que quando executado como cyclicquine.batsaídas

@type cyclicquine.bat

Que quando executado gera o arquivo em lotes original.

RProgN , 4 bytes.

A comunidade parece considerar esse tipo de coisa como uma trapaça , o que satisfaz os critérios.

1
2

Com uma nova linha à direita.

Isso imprime

2
1

Com uma nova linha à direita, que imprime o primeiro código.

RProgN imprime a pilha aparecendo, de cima para baixo.

Experimente online!

Jolf, 6 bytes

1q_a_q

Quando executado, isso gera:

q_a_q1

Que por sua vez, produz 1q_a_q.

Experimente aqui!

Explicação

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)))()

Saídas:

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

-1 byte (@ETHProductions): use 0 no regex em vez de \ d

Bash + Sed, 15 bytes

Mesma idéia que a resposta de Dennis .

sed y/xz/zx/ $0

Bash, Cat e Rev, 19 16 bytes

rev $0 # 0$  ver

-3 graças a @izabera

> <>, 16 bytes

"$r00gol?!;50.01

Experimente aqui!

Saídas

"$r00gol?!;50.10

Esta é uma modificação da fornecida aqui . Não tenho certeza se está trapaceando, ele lê o codebox e o exibe.