Tu desafío es simple. Escriba dos programas que no compartan caracteres que se muestren entre sí

Ejemplo

Dos programas P y Q son quines mutuamente excluyentes si:

1. P salidas Q
2. Q salidas P
3. No hay un carácter c que pertenezca tanto a P como a Q
4. Cada programa P y Q son quines adecuados
   1. Esto cuenta las quines vacías y las quines que leen su propio código fuente (o el del otro) como inválido .

Más reglas

• La duración combinada más corta de estos programas gana. Es decir, el tamaño ( P ) + tamaño ( Q ) es su puntaje, y gana el puntaje más bajo.
• Ambos programas están en el mismo idioma.
• Cada programa puede ser un programa completo o una función, y no necesitan ser lo mismo.
  • Por ejemplo, P puede ser un programa completo y Q puede ser una función.

Verificación

¡ Pruébalo en línea! El fragmento aquí puede verificar si dos programas son mutuamente excluyentes. Las entradas se ponen en los dos primeros argumentos.

> <> , Puntuación: 41 + 41 = 82

Editar: ambos contenían un 3. Corregido

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

y

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

Pruébalo en línea! (intercambie las líneas para obtener el otro resultado) ¡ Con verificación esta vez!

><>es un lenguaje especialmente difícil de usar aquí, ya que solo hay una forma de generar caracteres, el comando o. Afortunadamente, podemos usar el comando p ut para colocar un oen el código fuente durante la ejecución, como en mi respuesta Programación en un mundo prístino.

Éste tomó mucha prueba y error. Comencé con los dos programas mutuamente excluyentes:

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

y

"r00gr40g8+X0pN+?Y0.data

Cada uno se transforma a sí mismo y sus datos en N, el primero restando y el segundo sumando. Luego emite esto a la inversa. El punto es que los datos después de cada programa son el otro programa en reversa, desplazado por N. ( Xes el número de celda donde el programa necesita poner el oe Y es la celda donde el puntero regresa. ?Es donde ose pone el) .

Ambos siguen la misma estructura, representada de diferentes maneras. Ejecutan un literal de cadena sobre todo el código y lo agregan a la pila. Recrean el comando literal de cadena que usaron y lo colocan en la parte inferior de la pila. Se desplazan sobre la pila, sumando / restando N a cada personaje e imprimiéndolos.

El primer programa usa 'como literal de cadena, y el simple d3*}para crear el valor 39 y empujarlo al final de la pila. El segundo usa "como literal de cadena con la misma función. Se reverses la pila, gets el carácter en la celda 0,0 y revierte la pila de nuevo. Luego gobtiene el valor en la celda 4,0 ( g) y le agrega 8 para obtener oy lo pone en X.

Ambos programas usan un método diferente de bucle. El primer programa usa el comando skip ( !) para ejecutar solo la mitad de las instrucciones mientras se dirige hacia la izquierda, invierte la dirección y ejecuta la otra mitad. El segundo usa el comando de salto ( .) para saltar hacia atrás al inicio del ciclo en la celda Y. Ambos se ejecutan hasta que no hay más elementos en la pila y los errores del programa.

Me encontré con una serie de problemas con la mayoría de los valores más bajos de N, porque cambiar un carácter lo convertiría en otro carácter esencial para ese programa (y, por lo tanto, no podría usarse como datos para el otro programa) o dos caracteres del dos programas cambiarían al mismo personaje. Por ejemplo:

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

etc.

Finalmente llegué a 10 ( a), donde pude evitar estos problemas. Puede haber una versión más corta en la que se invierten los cambios, y el primer programa agrega N mientras que el segundo lo resta. Sin embargo, esto podría ser peor, ya que el primer programa generalmente está en el extremo inferior de la escala ASCII, por lo que restar es mejor para evitar conflictos.

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

Pruébalo en línea!

Script de verificación

Gracias a @Nathaniel por la idea de usar Forth, me recordó en los comentarios que Forth no distingue entre mayúsculas y minúsculas . Luego vinieron los cambios de humor: he encontrado razones por las que esto no funcionará, seguido de soluciones a estos problemas, una y otra vez. Todo mientras hago girar mi bicicleta de entrenamiento en interiores como una ruleta intranquila al revés y deformada (solo tienes que agarrar un extremo del manillar e inclinarlo un poco).

Antes de escribir estos programas, redacté qué caracteres pueden ser utilizados por cada programa. Específicamente, el segundo programa solo puede usar letras mayúsculas, dígitos decimales, tabulaciones y comas. Esto significaría que el primer programa es todo en minúsculas, pero usé algunas letras mayúsculas para sus valores ASCII.

Debido a que las pestañas son difíciles de manejar, en su lugar usaré espacios en la explicación.

El primer programa tiene la forma s" code"code: s"comienza un literal de cadena, que luego es procesado por la segunda copia del código, un marco de trabajo estándar. Sin embargo, en lugar de generar su propio código fuente, creará el otro programa, que se ve así:

• HERE
• Por cada 8 bytes en la cadena original, 64-bit-number-literal ,
• length-of-the-string
• 115 EMIT 34 EMIT 9 EMIT 2DUP TYPE 34 EMIT TYPE

Esto usa el espacio de datos de Forth. HEREdevuelve el puntero al final del área de espacio de datos actualmente asignada y ,agrega una celda llena de un número. Por lo tanto, los primeros tres puntos pueden verse como un literal de cadena creado usando s". Para finalizar el segundo programa:

• EMIT genera un carácter dado su valor ASCII, entonces:
  • 115 EMIT imprime en minúsculas s
  • 34 EMIT imprime el carácter de la cita "
  • 9 EMIT imprime una pestaña
• 2DUPduplica los dos elementos superiores en la pila ( a b -- a b a b ), aquí está el puntero y la longitud de la cadena
• TYPE imprime una cadena para generar la primera copia del código
• 34 EMITimprime la cita de cierre "y finalmente
• TYPE genera la segunda copia del código

Veamos cómo funciona el primer programa. En muchos casos, se deben evitar los números, lo que se hace usando la 'xextensión de sintaxis gforth para literales de caracteres, y algunas veces restando el valor ASCII del espacio, que se puede obtener 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 terminar esto, me gustaría decir que intenté usar EVALUATE, pero el segundo programa se vuelve más grande que los dos presentados anteriormente. De todos modos, aquí 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

Si logra jugar golf lo suficiente como para superar mi s" ..."...enfoque, continúe y publíquelo como su propia respuesta.

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

Ambos programas imprimen a la salida estándar.

El primer programa perl contiene principalmente caracteres ASCII imprimibles y nuevas líneas, y termina exactamente en una nueva línea, pero las dos letras ÿ representan el byte no 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]

El segundo contiene principalmente bytes no ASCII, incluidos varios caracteres de alto control que se reemplazan por estrellas en esta publicación, y no hay líneas nuevas en absoluto:

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

Un hexdump del primer programa con xxdes:

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].

Y un hexdump del segundo programa es:

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                           .....~

En el segundo programa, la cadena entre comillas (189 bytes de longitud, delimitada por tildes) es el primer programa completo, excepto la nueva línea final, solo codificada por bits que complementa cada byte. El segundo programa simplemente decodifica la cadena complementando cada uno de los bytes, lo que el ~operador hace en perl. El programa imprime la cadena decodificada seguida de una nueva línea (el saymétodo agrega una nueva línea).

En esta construcción, el decodificador del segundo programa usa solo seis caracteres ASCII diferentes, por lo que el primer programa puede ser prácticamente arbitrario, siempre que solo contenga caracteres ASCII y excluya esos seis caracteres. No es difícil escribir ningún programa perl sin usar esos cinco caracteres. La lógica de quine real se encuentra así en el primer programa.

En el primer programa, la lógica de quine utiliza un diccionario de 11 palabras de largo @fy ensambla la salida de esas palabras. Las primeras palabras repiten la mayor parte del código fuente del primer programa. El resto de las palabras son caracteres individuales específicos. Por ejemplo, la palabra 5 es una tilde, que es el delimitador para el literal de dos cadenas en el segundo programa. La lista de números entre paréntesis es la receta para las palabras que se imprimirán en qué orden. Este es un método de construcción general bastante ordinario para quines, el único giro en este caso es que las primeras palabras del diccionario se imprimen con sus bytes complementados a nivel de bits.

Haskell , 306 + 624 = 930 bytes

Programa 1: una función anónima que toma un argumento ficticio y devuelve una cadena.

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

Pruébalo en línea!

Programa 2: q[[40,...]]al final es una función anónima que toma un argumento ficticio y devuelve una cadena.

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]]

Pruébalo en línea!

Conjunto de caracteres 1 (incluye espacio):

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

Conjunto de caracteres 2 (incluye nueva línea):

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

Como solo el conjunto 1 contiene caracteres no ASCII, sus bytes UTF-8 también son disjuntos.

Cómo funciona

• El programa 1 generalmente se escribe con expresiones lambda, espacios y paréntesis, uso libre de funciones alfanuméricas integradas y con los datos de quine como literales de cadena al final.

  • El propio código central del Programa 1 se convierte en datos literales de cadena simplemente rodeándolo con comillas.
    • Para respaldar esto, cada barra invertida va seguida de ao b, que forman secuencias de escape válidas que se realizan de manera circular show.
    • Otro pequeño beneficio es que a, by cson las únicas letras minúsculas cuyos códigos ASCII son inferiores a 100, ahorrando un dígito en la codificación numérica utilizada por el programa 2.
  • La codificación literal de cadena del código central del programa 2 está más ofuscada al usar Unicode no ASCII: cada carácter tiene 182 agregados a su punto de código para garantizar que no haya superposición con los caracteres originales.
    • 182 solía ser 128, hasta que me di cuenta de que podía abusar del hecho de que 182 es el doble de la longitud del literal de cadena para que el código del programa 1 acorte la decodificación. (Como beneficio adicional, el programa 2 puede usar nuevas líneas).

• El programa 2 generalmente se escribe con ecuaciones de función de nivel superior (excepto la anónima final), literales de caracteres y números decimales, sintaxis de lista / rango y operadores, y con los datos de quine como una lista de listas de Ints al final.

  • El código central del Programa 1 está codificado como una lista de sus puntos de código, con una doble comilla final.
  • El código central del programa 2 está codificado como la lista de puntos de código del literal de cadena utilizado en el programa 1, aún desplazado hacia arriba por 182.

Tutorial, programa 1

• by cson los valores de los literales de cadena para el programa 2 y 1, respectivamente, dados como argumentos finales a la expresión lambda. ()es un argumento ficticio únicamente para satisfacer la regla de PPCG de que el programa debe definir una función.
• foldr(\a->map pred)b(show()>>c)decodifica la cadena bal código central del programa 2 aplicándolo map predvarias veces igual a la longitud de show()>>c == c++c, o 182.
• tail(show c)convierte la cadena cal código central del programa 1, con una doble comilla final añadida.
• :pure bcombina esto en una lista con la cadena b.
• map(map fromEnum)$ Convierte las cadenas en listas de puntos de código.
• `mappend`show(...) serializa la lista de listas resultante y finalmente la agrega al código central del programa 2.

Tutorial, programa 2

• El nivel superior z~z=[[['@','0'..]!!4..]!!z]es una función que convierte los puntos de código en caracteres (necesarios para escribir, ya que no todos los caracteres toEnumestán disponibles).
  • Su argumento de punto de código también se llama z. El marcador de pereza ~no tiene efecto en esta posición, pero evita un carácter de espacio.
  • ['@','0'..] es un rango de lista de pasos hacia atrás que comienza en el código ASCII 64, y luego salta 16 en cada paso
  • Aplicar !!4esto da un \NULcarácter.
  • Ajustar eso en un [ ..]rango proporciona una lista de todos los caracteres, que !!zindexa.
  • El personaje finalmente se envuelve en una lista singleton. Esto permite mapear la función zsobre listas usando en =<<lugar de las no disponibles mapy <$>.
• El nivel superior q[x,q]_=z=<<x++q++[34,34]++xes una función que construye el programa 1 de la lista de datos de quine.
  • xson los datos para el núcleo del programa 1 (incluida una comilla doble final) y el interno qson los datos ofuscados para el núcleo del programa 2. _es otro argumento ficticio únicamente para hacer que la función anónima final sea una función en lugar de solo una cadena.
  • x++q++[34,34]++x concatena las piezas, incluidas dos comillas dobles con código ASCII 34.
  • z=<<construye el programa 1 mapeando zsobre la concatenación para convertir de puntos de código a caracteres.
• La final q[[40,...]]es una función anónima que se combina qcon los datos de quine.

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

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

Pruébalo en línea!

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

Pruébalo en línea!

El primer programa hace lo siguiente:

“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: 'ỌṘ'.

Esto deja las cadenas 79,7806,8318,7885,7769,338,115y ỌṘcomo los dos argumentos de la cadena y están implícitamente concatenados e impresos al final.

El segundo programa calcula el chr( Ọ) de la lista de números que devuelve OṾ⁾ọṙŒs. Ṙimprime “OṾ⁾ọṙŒs”(con comillas) y devuelve la entrada, dejando “OṾ⁾ọṙŒs”OṾ⁾ọṙŒscomo salida completa.

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

"lF{3+|3d*HqlJJJQpp2

Pruébalo en línea!

'5ssTMMMotK-g6.6~Io

Pruébalo en línea!

¡Verifíquelo en línea!

Cómo trabajan ellos

"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 de la respuesta de Jo King> <> . Al tener muchos más comandos alternativos para salida y repetición, no hubo necesidad de go p, y los dos cuerpos principales se hicieron mucho más cortos.

Otra diferencia principal es que genero la cita del oponente directamente en la parte superior de la pila. De esta manera, era un poco más fácil mantener el invariante quote + my code + opponent code(reversed and shifted).