Seu desafio é simples. Escreva dois programas que não compartilhem caracteres que tenham saída um do outro.

Exemplo

Dois programas P e Q são quines mutuamente exclusivos se:

1. Saídas P Q
2. Q produz P
3. Não existe um caractere c que pertença a P e Q
4. Cada programa P e Q são quines adequados
   1. Isso considera quines vazios e quines que lêem seu próprio código-fonte (ou o do outro) como inválido .

Mais regras

• O menor comprimento combinado desses programas vence. Ou seja, tamanho ( P ) + tamanho ( Q ) é a sua pontuação, e a pontuação mais baixa vence.
• Ambos os programas estão no mesmo idioma
• Cada programa pode ser um programa ou função completo e não precisa ser o mesmo.
  • Por exemplo, P pode ser um programa completo e Q pode ser uma função.

Verificação

Este Experimente online! O snippet aqui pode verificar se dois programas são ou não mutuamente exclusivos. As entradas são colocadas nos dois primeiros argumentos.

> <> , Pontuação: 41 + 41 = 82

Editar: ambos continham um 3. Corrigido

'd3*}>a!o-!<<8:5@lI55>@z:5ll55>>q:>|q::|,

e

"r00gr40g44++bb+0p64++?b6+0.22#eW4s )Z

Experimente online! (troque as linhas para obter a outra saída) Com a verificação desta vez!

><>é uma linguagem especialmente difícil de usar aqui, como há apenas uma maneira de caracteres de saída, o comando o. Felizmente, podemos usar o comando p ut para colocar um ono código-fonte durante a execução, como na minha resposta de Programação em um mundo intocado .

Este levou muitas tentativas e erros. Comecei com os dois programas mutuamente exclusivos:

'd3*}>N!o-!<<data

e

"r00gr40g8+X0pN+?Y0.data

Cada um se transforma e seus dados por N, o primeiro subtraindo e o segundo adicionando. Em seguida, o resultado é inverso. O ponto é que os dados após cada programa são o outro programa em sentido inverso, deslocados por N. ( Xé o número da célula onde o programa precisa colocar a otecla e Y é a célula na qual o ponteiro volta para. ?É onde ela oé colocada) .

Ambos seguem a mesma estrutura, representada de maneiras diferentes. Eles executam uma string literal sobre todo o código, adicionando-o à pilha. Eles recriam o comando literal de cadeia de caracteres que eles usaram e o colocam na parte inferior da pilha. Eles passam pela pilha, adicionando / subtraindo N a cada caractere e imprimindo-os.

O primeiro programa usa 'como a string literal e o simples d3*}de criar o valor 39 e empurrá-lo para o final da pilha. O segundo usa "como a string literal com a mesma função. Ele reverses a pilha, gets o caractere na célula 0,0 e inverte a pilha novamente. Em seguida, ele gdefine o valor na célula 4,0 ( g) e adiciona 8 a ele para obter oe coloca isso em X.

Ambos os programas usam um método diferente de loop. O primeiro programa usa o comando skip ( !) para executar apenas metade das instruções enquanto vai para a esquerda, inverte a direção e executa a outra metade. O segundo usa o comando jump ( .) para retroceder para o início do loop na célula Y. Ambos são executados até que não haja mais itens na pilha e os erros do programa.

Eu tive vários problemas com a maioria dos valores mais baixos de N, porque a troca de um caractere o tornaria outro caractere essencial para esse programa (e, portanto, não poderia ser usado como dados para o outro programa) ou dois caracteres do dois programas mudariam para o mesmo personagem. Por exemplo:

1. ++1 = ,= --1
2. .+2 = 0
3. *= --3
4. g+4 = k= o-4

etc.

Finalmente cheguei a 10 ( a), onde consegui evitar esses problemas. Pode haver uma versão mais curta em que os turnos são revertidos e o primeiro programa está adicionando N enquanto o segundo o subtrai. Isso pode ser pior, porém, como o primeiro programa geralmente está na extremidade inferior da escala ASCII, é melhor subtrair para evitar conflitos.

Quarto (gforth little-endian de 64 bits) , 428 + 637 = 1065 bytes

s"	:	l	bl	-	;	:	m	l	emit	;	:	s	space	;	:	z	m	m	m	m	s	;	:	p	.	't	'i	'm	'e	z	;	'e	'r	'e	'h	z	:	q	>r	char	l	bl	l	do	dup	@	.	'L	m	s	cell+	loop	r>	.	;	:	n	'e	'p	'y	't	z	;	q	;	's	p	'B	l	p	#tab	p	'p	'u	'd	'Q	char+	z	n	'B	l	p	n":	l	bl	-	;	:	m	l	emit	;	:	s	space	;	:	z	m	m	m	m	s	;	:	p	.	't	'i	'm	'e	z	;	'e	'r	'e	'h	z	:	q	>r	char	l	bl	l	do	dup	@	.	'L	m	s	cell+	loop	r>	.	;	:	n	'e	'p	'y	't	z	;	q	;	's	p	'B	l	p	#tab	p	'p	'u	'd	'Q	char+	z	n	'B	l	p	n

HERE 3245244174817823034 , 7784873317282429705 , 665135765556913417 , 7161128521877883194 , 682868438367668581 , 679209482717038957 , 680053688600562035 , 678116140452874542 , 682868623551327527 , 680649414991612219 , 682868636436227367 , 7136360695317203258 , 7809815063433470312 , 8458896374132993033 , 5487364764302575984 , 7810758020979846409 , 680166068077538156 , 4181938639603318386 , 8081438386390920713 , 8793687458429085449 , 2812844354006760201 , 7784826166316108147 , 676210045490917385 , 681493840106293616 , 7521866046790788135 , 679491013524025953 , 7928991804732031527 , 216 115 EMIT 34 EMIT 9 EMIT 2DUP TYPE 34 EMIT TYPE 

Experimente online!

Script de verificação

Obrigado a Nathaniel pela idéia de usar o Forth - ele me lembrou nos comentários que Forth não diferencia maiúsculas de minúsculas . Depois vieram as mudanças de humor - eu tenho encontrado razões pelas quais isso não vai funcionar, seguidas por soluções para esses problemas, repetidas vezes. Enquanto gira a minha bicicleta de treinamento indoor como um girador de fidget deformado e deformado (basta pegar uma extremidade do guidão e inclinar um pouco).

Antes de escrever esses programas, rascunhei quais caracteres podem ser usados ​​por qual programa. Especificamente, o segundo programa pode usar apenas letras maiúsculas, dígitos decimais, tabulações e vírgulas. Isso significa que o primeiro programa é todo em minúsculas, mas usei algumas letras maiúsculas para seus valores ASCII.

Como as guias são pesadas, usarei espaços na explicação.

O primeiro programa é do formato s" code"code- s"inicia uma literal de cadeia de caracteres, que é processada pela segunda cópia do código - uma estrutura padrão de quine. No entanto, em vez de emitir seu próprio código-fonte, ele criará o outro programa, que se parece com isso:

• HERE
• Para cada 8 bytes na cadeia original, 64-bit-number-literal ,
• length-of-the-string
• 115 EMIT 34 EMIT 9 EMIT 2DUP TYPE 34 EMIT TYPE

Isso usa o espaço de dados da Forth. HEREretorna o ponteiro para o final da área de espaço de dados alocada no momento e ,acrescenta uma célula preenchida com um número a ele. Portanto, os três primeiros pontos de marcador podem ser vistos como uma literal de string criada usando s". Para finalizar o segundo programa:

• EMIT gera um caractere devido ao seu valor ASCII, portanto:
  • 115 EMIT imprime uma letra minúscula s
  • 34 EMIT imprime o caractere de citação "
  • 9 EMIT imprime uma guia
• 2DUPduplica os dois principais elementos da pilha ( a b -- a b a b ), aqui está o ponteiro e o comprimento da string
• TYPE imprime uma string para gerar a primeira cópia do código
• 34 EMITimprime a cotação de fechamento "e, finalmente,
• TYPE gera a segunda cópia do código

Vamos ver como o primeiro programa funciona. Em muitos casos, é necessário evitar números, o que é feito usando a 'xextensão de sintaxe gforth para literais de caracteres e, algumas vezes, subtraindo o valor ASCII do espaço, que pode ser obtido usando bl:

s" ..."      \ the data
: l bl - ;   \ define a word, `l`, that subtracts 32
: m l emit ; \ define a word, `m`, that outputs a character. Because 32 is
             \ subtracted using `l`, lowercase characters are converted to
             \ uppercase, and uppercase characters are converted to some
             \ symbols, which will become useful later
: z m m m m space ; \ `z` outputs four characters using `m`, followed by a
                    \ space. This is very useful because all words used in the
                    \ second program are four characters long
: p . 't 'i 'm 'e z ; \ define a word, `p`, that, given a number, outputs that
                      \ number, followed by a space, `EMIT`, and another space
'e 'r 'e 'h z \ here is where outputting the second program starts - `HERE `
: q \ define a helper word, `q`, that will be called only once. This is done
    \ because loop constructs like do...loop can't be used outside of a word.
  >r \ q is called with the address and the length of the data string. >r saves
     \ the length on the return stack, because we don't need it right now. While
     \ it might seem like this is too complicated to be the best way of doing
     \ this for codegolf, just discaring the length would be done using four
     \ characters - `drop`, which would give you the same bytecount if you could
     \ get the length again in... 0 characters.
  char l \ get a character from after the call to q, which is `;`, with the
         \ ASCII value of $3B, subtract $20 to get $1B, the number of 64-bit
         \ literals necessary to encode the string in the second program.
  bl l \ a roundabout way to get 0
  do   \ iterate from 0 (inclusive) to $1B (exclusive)
    \ on the start of each iteration, the address of the cell we are currently
    \ processing is on the top of the stack.
    dup @ . \ print the value. The address is still on the stack.
    'L m space \ the ASCII value of L is exactly $20 larger than the one of ,
    cell+ \ go to the next cell
  loop
  r> . \ print the length of the string
;
: n 'e 'p 'y 't z ; \ define a word, `n`, that outputs `TYPE`
q ; \ call q, and provide the semicolon for `char` (used to encode the length
    \ of the string in 64-bit words). Changing this to an uppercase U should
    \ make this work on 32-bit systems, but I don't have one handy to check that
's p \ print the code that outputs the lowercase s
'B l p \ likewise, 'B l <=> $42 - $20 <=> $22 <=> the ASCII value of a comma
#tab p \ print the code that outputs a tab
'p 'u 'd 'Q char+ z \ char+ is the best way to add 1 without using any digits.
                    \ it is used here to change the Q to an R, which can't be
                    \ used because of `HERE` in the second program. R has an
                    \ ASCII value exactly $20 larger than the ASCII value of 2,
                    \ so this line outputs the `2DUP`.
n 'B l p n \ output TYPE 34 EMIT TYPE to finish the second program. Note the
           \ that the final `n` introduces a trailing space. Trying to remove
           \ it adds bytes.

Para finalizar, gostaria de dizer que tentei usar EVALUATE, mas o segundo programa se torna maior que os dois apresentados acima. Enfim, aqui está:

: s s" ; s evaluate"s" : l bl - ; : m l emit ; : d here $b $a - allot c! ; : c here swap dup allot move ; : q bl l do #tab emit dup @ bl l u.r cell+ #tab emit 'L m loop ; here bl 'B l 's bl 's bl 'Z l d d d d d d d -rot c bl 'B l 's 'B l d d d d s c 'B l d c 'e 'r 'e 'h m m m m 'A q #tab emit 'e 'p 'y 't m m m m"; s evaluate

Se você conseguir jogar o suficiente para superar minha s" ..."...abordagem, vá em frente e publique como sua própria resposta.

Perl, (311 + 630 = 941 bytes) 190 + 198 = 388 bytes

Ambos os programas são impressos na saída padrão.

O primeiro programa perl contém principalmente caracteres ASCII imprimíveis e novas linhas, e termina em exatamente uma nova linha, mas as duas letras ÿ representam o byte não ASCII \ xFF:

@f='^"ÿ"x92;@f=(@f,chr)for 115,97,121,36,126,191,153,194,216,113;print@f[1..5,5,10,5..9,0,9,0,5]'^"ÿ"x92;@f=(@f,chr)for 115,97,121,36,126,191,153,194,216,113;print@f[1..5,5,10,5..9,0,9,0,5]

O segundo contém principalmente bytes não ASCII, incluindo vários caracteres de alto controle que são substituídos por estrelas nesta postagem e nenhuma nova linha:

say$~~q~¿*ÂØ¡Ý*Ý*ÆÍÄ¿*Â׿*Ó***Ö***ßÎÎÊÓÆÈÓÎÍÎÓÌÉÓÎÍÉÓÎÆÎÓÎÊÌÓÎÆËÓÍÎÉÓÎÎÌÄ*****¿*¤ÎÑÑÊÓÊÓÎÏÓÊÑÑÆÓÏÓÆÓÏÓʢءÝ*Ý*ÆÍÄ¿*Â׿*Ó***Ö***ßÎÎÊÓÆÈÓÎÍÎÓÌÉÓÎÍÉÓÎÆÎÓÎÊÌÓÎÆËÓÍÎÉÓÎÎÌÄ*****¿*¤ÎÑÑÊÓÊÓÎÏÓÊÑÑÆÓÏÓÆÓÏÓÊ¢~

Um hexdump do primeiro programa com xxdé:

00000000: 4066 3d27 5e22 ff22 7839 323b 4066 3d28  @f='^"."x92;@f=(
00000010: 4066 2c63 6872 2966 6f72 2031 3135 2c39  @f,chr)for 115,9
00000020: 372c 3132 312c 3336 2c31 3236 2c31 3931  7,121,36,126,191
00000030: 2c31 3533 2c31 3934 2c32 3136 2c31 3133  ,153,194,216,113
00000040: 3b70 7269 6e74 4066 5b31 2e2e 352c 352c  ;print@f[1..5,5,
00000050: 3130 2c35 2e2e 392c 302c 392c 302c 355d  10,5..9,0,9,0,5]
00000060: 275e 22ff 2278 3932 3b40 663d 2840 662c  '^"."x92;@f=(@f,
00000070: 6368 7229 666f 7220 3131 352c 3937 2c31  chr)for 115,97,1
00000080: 3231 2c33 362c 3132 362c 3139 312c 3135  21,36,126,191,15
00000090: 332c 3139 342c 3231 362c 3131 333b 7072  3,194,216,113;pr
000000a0: 696e 7440 665b 312e 2e35 2c35 2c31 302c  int@f[1..5,5,10,
000000b0: 352e 2e39 2c30 2c39 2c30 2c35 5d0a       5..9,0,9,0,5].

E um hexdump do segundo programa é:

00000000: 7361 7924 7e7e 717e bf99 c2d8 a1dd 00dd  say$~~q~........
00000010: 87c6 cdc4 bf99 c2d7 bf99 d39c 978d d699  ................
00000020: 908d dfce ceca d3c6 c8d3 cecd ced3 ccc9  ................
00000030: d3ce cdc9 d3ce c6ce d3ce cacc d3ce c6cb  ................
00000040: d3cd cec9 d3ce cecc c48f 8d96 918b bf99  ................
00000050: a4ce d1d1 cad3 cad3 cecf d3ca d1d1 c6d3  ................
00000060: cfd3 c6d3 cfd3 caa2 d8a1 dd00 dd87 c6cd  ................
00000070: c4bf 99c2 d7bf 99d3 9c97 8dd6 9990 8ddf  ................
00000080: cece cad3 c6c8 d3ce cdce d3cc c9d3 cecd  ................
00000090: c9d3 cec6 ced3 ceca ccd3 cec6 cbd3 cdce  ................
000000a0: c9d3 cece ccc4 8f8d 9691 8bbf 99a4 ced1  ................
000000b0: d1ca d3ca d3ce cfd3 cad1 d1c6 d3cf d3c6  ................
000000c0: d3cf d3ca a27e                           .....~

No segundo programa, a cadeia de caracteres entre aspas (189 bytes de comprimento, delimitada por tildes) é o primeiro programa inteiro, exceto a nova linha final, codificada apenas complementando bit a bit cada bit. O segundo programa simplesmente decodifica a string complementando cada um dos bytes, o que o ~operador faz em perl. O programa imprime a string decodificada seguida por uma nova linha (o saymétodo adiciona uma nova linha).

Nesta construção, o decodificador do segundo programa usa apenas seis caracteres ASCII diferentes, de modo que o primeiro programa pode ser praticamente arbitrário, desde que contenha apenas caracteres ASCII e exclua esses seis caracteres. Não é difícil escrever nenhum programa perl sem usar esses cinco caracteres. A lógica quine atual está, portanto, no primeiro programa.

No primeiro programa, a lógica quine usa um dicionário de 11 palavras @fe monta a saída dessas palavras. As primeiras palavras repetem a maior parte do código fonte do primeiro programa. O restante das palavras são caracteres únicos específicos. Por exemplo, a palavra 5 é um til, que é o delimitador para as duas cadeias literais no segundo programa. A lista de números entre colchetes é a receita para quais palavras serão impressas em que ordem. Este é um método de construção geral bastante comum para quines, a única mudança nesse caso é que as primeiras palavras do dicionário são impressas com seus bytes complementados em bits.

Haskell , 306 + 624 = 930 bytes

Programa 1: Uma função anônima pegando um argumento fictício e retornando uma string.

(\b c()->foldr(\a->map pred)b(show()>>c)`mappend`show(map(map fromEnum)$tail(show c):pure b))"İĴİóđđđÝöÝâÝæÝääē××êääē××İēÀħđĮâħēĕóİóòòĮááħááđéêâéêēááĮÀħ""(\b c()->foldr(\a->map pred)b(show()>>c)`mappend`show(map(map fromEnum)$tail(show c):pure b))"

Experimente online!

Programa 2: q[[40,...]]no final, é uma função anônima que pega um argumento fictício e retorna uma string.

z~z=[[['@','0'..]!!4..]!!z]
q[x,q]_=z=<<x++q++[34,34]++x
q[[40,92,98,32,99,40,41,45,62,102,111,108,100,114,40,92,97,45,62,109,97,112,32,112,114,101,100,41,98,40,115,104,111,119,40,41,62,62,99,41,96,109,97,112,112,101,110,100,96,115,104,111,119,40,109,97,112,40,109,97,112,32,102,114,111,109,69,110,117,109,41,36,116,97,105,108,40,115,104,111,119,32,99,41,58,112,117,114,101,32,98,41,41,34],[304,308,304,243,273,273,273,221,246,221,226,221,230,221,228,228,275,215,215,234,228,228,275,215,215,304,275,192,295,273,302,226,295,275,277,243,304,243,242,242,302,225,225,295,225,225,273,233,234,226,233,234,275,225,225,302,192,295]]

Experimente online!

Conjunto de caracteres 1 (inclui espaço):

 "$()-:>E\`abcdefhilmnoprstuw×ÝáâäæéêñòóöđēĕħĮİĴ

Conjunto de caracteres 2 (inclui nova linha):

!'+,.0123456789<=@[]_qxz~

Como apenas o conjunto 1 contém caracteres não ASCII, seus bytes UTF-8 também são disjuntos.

Como funciona

• O Programa 1 geralmente é escrito com expressões lambda, espaços e parênteses, uso gratuito de funções alfanuméricas incorporadas e com os dados quine como literais de string no final.

  • O código principal do próprio programa 1 é transformado em dados literais de cadeia de caracteres simplesmente envolvendo-o entre aspas.
    • Para suportar isso, toda barra invertida é seguida por aou b, que formam seqüências de escape válidas que percorrem o caminho show.
    • Outro pequeno benefício é que a, be csão as únicas letras minúsculas cujos códigos ASCII são menores que 100, economizando um dígito na codificação numérica usada pelo programa 2.
  • A codificação literal de cadeia de caracteres do código principal do programa 2 é mais ofuscada usando Unicode não ASCII: Cada caractere foi adicionado ao seu ponto de código 182 para garantir que não haja sobreposição com os caracteres originais.
    • 182 costumava ser 128, até que percebi que poderia abusar do fato de 182 ter o dobro do comprimento da string literal para o código do programa 1 reduzir a decodificação. (Como bônus, o programa 2 pode usar novas linhas.)

• O Programa 2 geralmente é escrito com equações de função de nível superior (exceto a final anônima), literais de caracteres e números decimais, sintaxe de lista / intervalo e operadores, e com os dados quine como uma lista de listas de Ints no final.

  • O código principal do programa 1 é codificado como uma lista de seus pontos de código, com uma citação dupla final.
  • O código principal do programa 2 é codificado como a lista de pontos de código da cadeia literal usada no programa 1, ainda deslocada para cima em 182.

Passo a passo, programa 1

• be csão os valores das literais de cadeia de caracteres para o programa 2 e 1, respectivamente, dados como argumentos finais para a expressão lambda. ()é um argumento falso apenas para satisfazer a regra do PPCG de que o programa deve definir uma função.
• foldr(\a->map pred)b(show()>>c)decodifica a string bno código principal do programa 2 aplicando map preda ela um número de vezes igual ao comprimento de show()>>c == c++c, ou 182.
• tail(show c)converte a string cno código principal do programa 1, com uma aspas dupla final anexada.
• :pure bcombina isso em uma lista com a sequência b.
• map(map fromEnum)$ converte as seqüências de caracteres em listas de pontos de código.
• `mappend`show(...) serializa a lista de listas resultante e, finalmente, anexa-a ao código principal do programa 2.

Passo a passo, programa 2

• O nível superior z~z=[[['@','0'..]!!4..]!!z]é uma função que converte pontos de código em caracteres (necessário para escrever, pois nem todos os caracteres toEnumestão disponíveis).
  • Seu argumento de ponto de código também é chamado z. O marcador de preguiça ~não tem efeito nessa posição, mas evita um caractere de espaço.
  • ['@','0'..] é um intervalo da lista de passos para trás, começando no código ASCII 64 e pulando 16 para baixo a cada passo.
  • A aplicação !!4a isso fornece um \NULpersonagem.
  • O agrupamento em um [ ..]intervalo fornece uma lista de todos os caracteres, que são !!zindexados.
  • O personagem é finalmente envolvido em uma lista de singleton. Isso permite mapear a função znas listas usando em =<<vez de indisponível mape <$>.
• O nível superior q[x,q]_=z=<<x++q++[34,34]++xé uma função que constrói o programa 1 a partir da lista de dados quine.
  • xsão os dados para o núcleo do programa 1 (incluindo uma citação dupla final) e os internos qsão os dados ofuscados para o núcleo do programa 2. _é outro argumento fictício apenas para tornar a função anônima final uma função em vez de apenas uma string.
  • x++q++[34,34]++x concatena as peças, incluindo duas aspas duplas com o código ASCII 34.
  • z=<<constrói o programa 1 mapeando za concatenação para converter de pontos de código em caracteres.
• A final q[[40,...]]é uma função anônima combinada qcom os dados do quine.

Gelatina , _{128 90 87 86 85 79} 16 + 32 = 48 bytes

“OṾ⁾ọṙŒs”OṾ⁾ọṙŒs

Experimente online!

79,7806,8318,7885,7769,338,115ỌṘ

Experimente online!

O primeiro programa faz o seguinte:

“OṾ⁾ọṙŒs”OṾ⁾ọṙŒs
“OṾ⁾ọṙŒs”          String literal: 'OṾ⁾ọṙŒs'
         O         ord: [79, 7806, 8318,...]
          Ṿ        Uneval. Returns '79,7806,8318,7885,7769,338,115'
           ⁾ọṙ     Two character string literal: 'ọṙ'
              Œs   Swap case the two char literal: 'ỌṘ'.

Isso deixa as strings 79,7806,8318,7885,7769,338,115e ỌṘos dois argumentos da cadeia e são implicitamente concatenadas e impressas no final.

O segundo programa calcula o chr( Ọ) da lista de números que retorna OṾ⁾ọṙŒs. Ṙimprime “OṾ⁾ọṙŒs”(entre aspas) e retorna a entrada, deixando “OṾ⁾ọṙŒs”OṾ⁾ọṙŒscomo saída total.

Gol> <> , _{23 + 23 = 46 22 + 22 = 44} 20 + 20 = 40 bytes

"lF{3+|3d*HqlJJJQpp2

Experimente online!

'5ssTMMMotK-g6.6~Io

Experimente online!

Verifique online!

Como eles trabalham

"lF{3+|3d*HqlJJJQpp2

"..."        Push everything to the stack
 lF{3+|      Add 3 to everything on the stack
       3d*   Push 39 `'`
          H  Print everything on the stack (from the top) and halt

'5ssTMMMotK-g6.6~Io

'...'        Push everything to the stack
 5ss         Push 37 (34 `"` + 3)
    T    t   Loop indefinitely...
     MMMo      Decrement 3 times, pop and print
               At the end, `o` tries to print charcode -3, which is fishy (thanks Jo King)
               Program terminates

Adaptado da resposta de Jo King> <> . Tendo muito mais comandos alternativos para saída e repetição, não havia necessidade de gou p, e os dois corpos principais ficaram muito mais curtos.

Outra diferença principal é que eu gero a cotação do oponente diretamente no topo da pilha. Dessa forma, era um pouco mais fácil manter o invariante de quote + my code + opponent code(reversed and shifted).