La tua sfida è semplice. Scrivi due programmi che non condividono caratteri che si generano l'un l'altro.

Esempio

Due programmi P e Q si escludono a vicenda se:

1. P uscite Q
2. Q uscite P
3. Non esiste alcun carattere c che appartiene sia a P che a Q.
4. Ogni programma P e Q sono quines appropriate
   1. Questo conta come vuoti quines e quines che leggono il loro codice sorgente (o dell'altro) come non valido .

Più regole

• Vince la durata combinata più breve di questi programmi. Cioè, size ( P ) + size ( Q ) è il tuo punteggio e vince il punteggio più basso.
• Entrambi i programmi sono nella stessa lingua
• Ogni programma può essere un programma o una funzione completi e non devono necessariamente essere gli stessi.
  • Ad esempio, P può essere un programma completo e Q può essere una funzione.

Verifica

Questo Provalo online! lo snippet qui può verificare se due programmi si escludono a vicenda. Gli input sono inseriti nei primi due argomenti.

> <> , Punteggio: 41 + 41 = 82

Modifica: entrambi contenevano un 3. Risolto

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

e

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

Provalo online! (Scambia le righe per ottenere l'altro output) Con verifica questa volta!

><>è un linguaggio particolarmente difficile da usare qui, poiché esiste solo un modo per emettere caratteri, il comando o. Fortunatamente, possiamo usare il comando p ut per inserire un ocodice sorgente durante l'esecuzione, come nella mia risposta Programmazione in un mondo incontaminato .

Questo ha richiesto molte prove ed errori. Ho iniziato con i due programmi reciprocamente esclusivi:

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

e

"r00gr40g8+X0pN+?Y0.data

Ognuno trasforma se stesso e i suoi dati con N, il primo sottraendo e il secondo aggiungendo. Quindi emette questo al contrario. Il punto è che i dati dopo ogni programma sono l'altro programma al contrario, spostati di N. ( Xè il numero di cella in cui il programma deve mettere il oe Y è la cella in cui il puntatore ritorna indietro. ?È dove oviene messo) .

Entrambi seguono la stessa struttura, rappresentata in modi diversi. Eseguono una stringa letterale sull'intero codice, aggiungendolo allo stack. Ricreano il comando letterale stringa che hanno usato e lo hanno messo in fondo alla pila. Passano sopra la pila, aggiungendo / sottraendo N a ciascun personaggio e stampandoli.

Il primo programma utilizza 'letteralmente la stringa e il semplice d3*}creare il valore 39 e spingerlo in fondo allo stack. Il secondo utilizza "come stringa letterale con la stessa funzione. E ' rInverte la pila, gETS il carattere cella di 0,0 e inverte di nuovo la pila. Quindi gimposta il valore nella cella 4,0 ( g) e ne aggiunge 8 per ottenere oe lo mette in X.

Entrambi i programmi utilizzano un diverso metodo di looping. Il primo programma utilizza il comando skip ( !) per eseguire solo metà delle istruzioni mentre si va a sinistra, inverte la direzione ed esegue l'altra metà. Il secondo usa il comando jump ( .) per saltare indietro all'inizio del loop nella cella Y. Entrambi funzionano fino a quando non ci sono più oggetti nello stack e gli errori del programma.

Mi sono imbattuto in una serie di problemi con la maggior parte dei valori più bassi di N, perché lo spostamento di un personaggio lo trasformerebbe in un altro personaggio essenziale per quel programma (e quindi non poteva essere usato come dati per l'altro programma) o due caratteri dal due programmi si sposteranno nello stesso personaggio. Per esempio:

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

eccetera.

Alla fine sono arrivato a 10 ( a), dove sono stato in grado di evitare questi problemi. Potrebbe esserci una versione più breve in cui i turni sono invertiti e il primo programma aggiunge N mentre il secondo lo sottrae. Questo potrebbe essere peggio, dato che il primo programma è generalmente all'estremità inferiore della scala ASCII, quindi è meglio sottrarre i conflitti per evitare conflitti.

Forth (gforth little-endian a 64 bit) , 428 + 637 = 1065 byte

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 

Provalo online!

Script di verifica

Grazie a @Nathaniel per l'idea di usare Forth - nei commenti mi ha ricordato che Forth non fa distinzione tra maiuscole e minuscole . Poi sono arrivati ​​gli sbalzi d'umore: ho trovato motivi per cui questo non funzionerà, seguito da soluzioni a questi problemi, ancora e ancora. Tutto mentre gira la mia bici da allenamento indoor come una spinner di fidget sovradimensionata e deformata (devi solo afferrare un'estremità del manubrio e inclinarla un po ').

Prima di scrivere questi programmi, ho redatto quali caratteri possono essere usati da quale programma. In particolare, il secondo programma può utilizzare solo lettere maiuscole, cifre decimali, tabulazioni e virgole. Ciò significherebbe che il primo programma è tutto in minuscolo, ma ho usato alcune lettere maiuscole per i loro valori ASCII.

Poiché le schede sono ingombranti, userò invece spazi nella spiegazione.

Il primo programma ha il formato s" code"code- s"inizia una stringa letterale, che viene quindi elaborata dalla seconda copia del codice - un framework quine standard. Tuttavia, invece di emettere il proprio codice sorgente, creerà l'altro programma, che assomiglia a questo:

• HERE
• Per ogni 8 byte nella stringa originale, 64-bit-number-literal ,
• length-of-the-string
• 115 EMIT 34 EMIT 9 EMIT 2DUP TYPE 34 EMIT TYPE

Questo utilizza lo spazio dati di Forth. HERErestituisce il puntatore alla fine dell'area dello spazio dati attualmente allocata e ,accoda una cella piena di un numero. Pertanto, i primi tre punti elenco possono essere visti come una stringa letterale creata usando s". Per terminare il secondo programma:

• EMIT genera un carattere dato il suo valore ASCII, quindi:
  • 115 EMIT stampa una lettera minuscola s
  • 34 EMIT stampa il carattere di citazione "
  • 9 EMIT stampa una scheda
• 2DUPduplica i primi due elementi nello stack ( a b -- a b a b ), qui è il puntatore a e la lunghezza della stringa
• TYPE stampa una stringa per produrre la prima copia del codice
• 34 EMITstampa la citazione di chiusura "e infine
• TYPE genera la seconda copia del codice

Vediamo come funziona il primo programma. In molti casi i numeri devono essere evitati, il che viene fatto usando l' 'xestensione della sintassi gforth per i letterali dei caratteri e talvolta sottraendo il valore ASCII dello spazio, che può essere ottenuto 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.

Per finire, vorrei dire che ho provato a usare EVALUATE, ma il secondo programma diventa più grande di entrambi quelli presentati sopra. Ad ogni modo, eccolo qui:

: 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 riesci a giocare a golf abbastanza in basso per superare il mio s" ..."...approccio, vai avanti e pubblicalo come risposta personale.

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

Entrambi i programmi stampano sullo standard output.

Il primo programma perl contiene principalmente caratteri ASCII e newline stampabili, e termina esattamente con una nuova riga, ma la lettera ÿ rappresenta il byte non 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]

Il secondo contiene principalmente byte non ASCII, inclusi diversi caratteri di controllo elevato che vengono sostituiti dalle stelle in questo post e nessuna nuova riga:

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

Un hexdump del primo programma con 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 un hexdump del secondo programma è:

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

Nel secondo programma, la stringa tra virgolette (lunga 189 byte, delimitata da tilde) è l'intero primo programma tranne la nuova riga finale, codificato solo completando bit per bit ogni byte. Il secondo programma semplicemente decodifica la stringa integrando ciascuno dei byte, cosa che l' ~operatore esegue in perl. Il programma stampa la stringa decodificata seguita da una nuova riga (il saymetodo aggiunge una nuova riga).

In questa costruzione, il decodificatore del secondo programma utilizza solo sei diversi caratteri ASCII, quindi il primo programma può essere praticamente arbitrario, purché contenga solo caratteri ASCII ed escluda quei sei caratteri. Non è difficile scrivere alcun programma perl senza usare quei cinque caratteri. La logica attuale di quine è quindi nel primo programma.

Nel primo programma, la logica di Quine utilizza un dizionario di 11 parole @fe assembla l'output di quelle parole. Le prime parole ripetono la maggior parte del codice sorgente del primo programma. Il resto delle parole sono caratteri singoli specifici. Ad esempio, la parola 5 è una tilde, che è il delimitatore per le due stringhe letterali nel secondo programma. L'elenco di numeri tra parentesi è la ricetta per la quale parole stampare in quale ordine. Questo è un metodo di costruzione generale piuttosto ordinario per le quines, l'unica svolta in questo caso è che le prime parole del dizionario sono stampate con i suoi byte integrati bit per bit.

Haskell , 306 + 624 = 930 byte

Programma 1: una funzione anonima che prende un argomento fittizio e restituisce una stringa.

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

Provalo online!

Programma 2: q[[40,...]]alla fine è una funzione anonima che prende un argomento fittizio e restituisce una stringa.

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

Provalo online!

Set di caratteri 1 (include spazio):

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

Set di caratteri 2 (include newline):

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

Poiché solo il set 1 contiene caratteri non ASCII, anche i loro byte UTF-8 sono disgiunti.

Come funziona

• Il programma 1 è generalmente scritto con espressioni lambda, spazi e parentesi, uso gratuito delle funzioni alfanumeriche incorporate e con i dati di quine come valori letterali di stringa alla fine.

  • Il codice core del programma 1 viene trasformato in dati letterali di stringa semplicemente racchiudendolo tra virgolette.
    • A supporto di ciò, ogni barra rovesciata è seguita da ao b, che formano sequenze di escape valide che vanno di andata e ritornoshow .
    • Un altro vantaggio è che piccolo a, be csono le solo minuscole cui codici ASCII sono meno di 100, risparmiando una cifra nella codifica numerica utilizzata dal programma 2.
  • La codifica letterale stringa del codice core del programma 2 è più offuscata utilizzando Unicode non ASCII: ogni carattere ha aggiunto 182 al suo punto di codice per garantire che non vi siano sovrapposizioni con i caratteri originali.
    • 182 era 128, fino a quando mi sono reso conto che avrei potuto abusare del fatto che 182 è il doppio della lunghezza della stringa letterale per il codice del programma 1 per abbreviare la decodifica. (Come bonus, il programma 2 può usare newline.)

• Il programma 2 è generalmente scritto con equazioni di funzione di livello superiore (tranne quella anonima finale), valori letterali dei caratteri e numeri decimali, sintassi elenco / intervallo e operatori e con i dati quine come un elenco di elenchi di Ints alla fine.

  • Il codice principale del Programma 1 è codificato come un elenco dei suoi punti di codice, con una doppia virgoletta finale.
  • Il codice core del programma 2 è codificato come l'elenco di punti di codice del valore letterale di stringa utilizzato nel programma 1, spostato ancora verso l'alto di 182.

Procedura dettagliata, programma 1

• be csono i valori dei letterali stringa per il programma 2 e 1, rispettivamente, dati come argomenti finali all'espressione lambda. ()è un argomento fittizio solo per soddisfare la regola di PPCG secondo cui il programma dovrebbe definire una funzione.
• foldr(\a->map pred)b(show()>>c)decodifica la stringa bnel codice principale del programma 2 applicando map predad essa un numero di volte uguale alla lunghezza di show()>>c == c++c, o 182.
• tail(show c)converte la stringa cnel codice principale del programma 1, con l'aggiunta di una doppia virgoletta finale.
• :pure bcombina questo in un elenco con la stringa b.
• map(map fromEnum)$ converte le stringhe in elenchi di punti di codice.
• `mappend`show(...) serializza l'elenco risultante di elenchi e infine lo aggiunge al codice principale del programma 2.

Procedura dettagliata, programma 2

• Il livello superiore z~z=[[['@','0'..]!!4..]!!z]è una funzione che converte i punti di codice in caratteri (necessario per scrivere poiché non tutti i caratteri intoEnum sono disponibili).
  • Viene anche chiamato l'argomento punto di codice z. L'indicatore di pigrizia~ non ha alcun effetto in questa posizione ma evita un carattere spaziale.
  • ['@','0'..] è un intervallo di elenchi di gradini all'indietro che inizia con il codice ASCII 64, quindi salta di 16 in giù per ogni passaggio.
  • Applicare !!4a questo dà un \NULcarattere.
  • Avvolgendolo in un [ ..]intervallo si ottiene un elenco di tutti i caratteri, che viene !!zindicizzato.
  • Il personaggio è finalmente racchiuso in una lista singleton. Ciò consente di mappare la funzione zsugli elenchi utilizzando =<<anziché l'indisponibile mape <$>.
• Il livello superiore q[x,q]_=z=<<x++q++[34,34]++xè una funzione che costruisce il programma 1 dall'elenco dei dati di Quine.
  • xsono i dati per il core del programma 1 (inclusa una doppia virgoletta finale) e l'interno qè i dati offuscati per il core del programma 2. _è un altro argomento fittizio solo per rendere la funzione anonima finale una funzione anziché una semplice stringa.
  • x++q++[34,34]++x concatena i pezzi, tra cui due virgolette doppie con codice ASCII 34.
  • z=<<costruisce il programma 1 mappando zsulla concatenazione per convertire da punti di codice a caratteri.
• Il finale q[[40,...]]è una funzione anonima che si combina qcon i dati di Quine.

Jelly , _{128 90 87 86 85 79} 16 + 32 = 48 byte

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

Provalo online!

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

Provalo online!

Il primo programma procede come segue:

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

Questo lascia le corde 79,7806,8318,7885,7769,338,115 e ỌṘcome i due argomenti della catena e sono implicitamente concatenati e stampati alla fine.

Il secondo programma calcola il chr( Ọ) dell'elenco di numeri che restituisce OṾ⁾ọṙŒs. Ṙstampa “OṾ⁾ọṙŒs”(tra virgolette) e restituisce l'input, lasciandolo “OṾ⁾ọṙŒs”OṾ⁾ọṙŒscome output completo.

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

"lF{3+|3d*HqlJJJQpp2

Provalo online!

'5ssTMMMotK-g6.6~Io

Provalo online!

Verifica online!

Come funzionano

"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

Adattato dalla risposta> <> di Jo King . Avendo molti più comandi alternativi per l'output e la ripetizione, non c'era bisogno di gop , e i due corpi principali divennero molto più brevi.

Un'altra differenza principale è che genera la quota dell'avversario direttamente in cima alla pila. In questo modo, era leggermente più facile mantenere l'invariante di quote + my code + opponent code(reversed and shifted).