Votre défi est simple. Écrivez deux programmes qui ne partagent aucun caractère qui se produisent mutuellement.

Exemple

Deux programmes P et Q sont des quines mutuellement exclusives si:

1. Sorties P Q
2. Q sorties P
3. Il n'y a pas de caractère c qui appartient à la fois à P et à Q
4. Chaque programme P et Q sont des quines correctes
   1. Cela compte les quines vides et les quines qui lisent leur propre code source (ou l'autre) comme non valides .

Plus de règles

• La durée combinée la plus courte de ces programmes l'emporte. Autrement dit, la taille ( P ) + la taille ( Q ) est votre score, et le score le plus bas l'emporte.
• Les deux programmes sont dans la même langue
• Chaque programme peut être un programme ou une fonction complète, et il n'est pas nécessaire qu'ils soient identiques.
  • Par exemple, P peut être un programme complet et Q peut être une fonction.

Vérification

Cette Essayez en ligne! L'extrait ici peut vérifier si deux programmes s'excluent mutuellement ou non. Les entrées sont placées dans les deux premiers arguments.

> <> , Score: 41 + 41 = 82

Edit: les deux contenaient un 3. Fixe

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

et

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

Essayez-le en ligne! (échangez les lignes pour obtenir l'autre sortie) Avec vérification cette fois!

><>est un langage particulièrement difficile à utiliser ici, car il n'y a qu'une seule façon de produire des caractères, la commande o. Heureusement, nous pouvons utiliser la commande p ut pour placer un odans le code source pendant l'exécution, comme dans mon réponse Programmation dans un monde vierge.

Celui-ci a pris beaucoup d'essais et d'erreurs. J'ai commencé avec les deux programmes mutuellement exclusifs:

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

et

"r00gr40g8+X0pN+?Y0.data

Chacun se transforme lui-même et ses données par N, le premier soustrait et le second additionne. Il sort ensuite cela en sens inverse. Le fait est que les données après chaque programme sont l'autre programme en sens inverse, décalées de N. ( Xest le numéro de cellule où le programme doit placer le oet Y est la cellule où le pointeur revient en boucle. ?Est l'endroit où oest placé) .

Les deux suivent la même structure, représentée de différentes manières. Ils exécutent un littéral de chaîne sur tout le code, l'ajoutant à la pile. Ils recréent la commande littérale de chaîne qu'ils ont utilisée et la placent au bas de la pile. Ils bouclent sur la pile, ajoutant / soustrayant N à chaque caractère et les imprimant.

Le premier programme utilise 'comme littéral de chaîne et le simple d3*}pour créer la valeur 39 et la pousser au bas de la pile. Le second utilise "comme littéral de chaîne avec la même fonction. Il révite la pile, gets le caractère à la cellule 0,0 et inverse à nouveau la pile. Il ajoute ensuite gla valeur à la cellule 4,0 ( g) et y ajoute 8 pour obteniro et met cela à X.

Les deux programmes utilisent une méthode différente de bouclage. Le premier programme utilise la commande skip ( !) pour exécuter seulement la moitié des instructions tout en allant à gauche, inverse la direction et exécute l'autre moitié. La seconde utilise la commande jump (. ) pour revenir en arrière au début de la boucle à la cellule Y. Ces deux s'exécutent jusqu'à ce qu'il n'y ait plus d'éléments sur la pile et les erreurs de programme.

J'ai rencontré un certain nombre de problèmes avec la plupart des valeurs inférieures de N, car le déplacement d'un caractère le transformerait en un autre caractère essentiel pour ce programme (et ne pourrait donc pas être utilisé comme données pour l'autre programme) ou deux caractères de la deux programmes passeraient au même caractère. Par exemple:

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

etc.

Finalement, je suis arrivé à 10 ( a), où j'ai pu éviter ces problèmes. Il peut y avoir une version plus courte où les décalages sont inversés et le premier programme ajoute N tandis que le second le soustrait. Cela pourrait être pire, car le premier programme se situe généralement dans la partie inférieure de l'échelle ASCII, il est donc préférable de soustraire pour éviter les conflits.

Forth (gforth 64 bits Little Endian) , 428 + 637 = 1065 octets

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 

Essayez-le en ligne!

Script de vérification

Merci à @Nathaniel pour l'idée d'utiliser Forth - il m'a rappelé dans les commentaires que Forth n'est pas sensible à la casse . Puis sont arrivées les sautes d'humeur - j'ai trouvé des raisons pour lesquelles cela ne fonctionnerait pas, suivi par des solutions à ces problèmes, encore et encore. Tout en faisant tourner mon vélo d'entraînement intérieur comme un spinner fidget déformé et déformé (il suffit de saisir une extrémité du guidon et de l'incliner un peu).

Avant d'écrire ces programmes, j'ai rédigé quels caractères peuvent être utilisés par quel programme. Plus précisément, le deuxième programme ne peut utiliser que des lettres majuscules, des chiffres décimaux, des tabulations et des virgules. Cela signifierait que le premier programme est entièrement en minuscules, mais j'ai utilisé des lettres majuscules pour leurs valeurs ASCII.

Étant donné que les onglets sont peu maniables, j'utiliserai plutôt des espaces dans l'explication.

Le premier programme est de la forme s" code"code- le s"démarre un littéral de chaîne, qui est ensuite traité par la deuxième copie du code - un cadre de quine standard. Cependant, au lieu de produire son propre code source, il créera l'autre programme, qui ressemble à ceci:

• HERE
• Pour chaque 8 octets de la chaîne d'origine, 64-bit-number-literal ,
• length-of-the-string
• 115 EMIT 34 EMIT 9 EMIT 2DUP TYPE 34 EMIT TYPE

Cela utilise l'espace de données de Forth. HERErenvoie le pointeur à la fin de la zone d'espace de données actuellement allouée et y ,ajoute une cellule remplie d'un nombre. Par conséquent, les trois premières puces peuvent être vues comme un littéral de chaîne créé à l'aide de s". Pour terminer le deuxième programme:

• EMIT renvoie un caractère donné sa valeur ASCII, donc:
  • 115 EMIT imprime un minuscule s
  • 34 EMIT imprime le caractère de citation "
  • 9 EMIT imprime un onglet
• 2DUPduplique les deux premiers éléments de la pile ( a b -- a b a b ), ici c'est le pointeur et la longueur de la chaîne
• TYPE imprime une chaîne pour sortir la première copie du code
• 34 EMITimprime le devis de clôture ", et enfin
• TYPE sort la deuxième copie du code

Voyons comment fonctionne le premier programme. Dans de nombreux cas, les nombres doivent être évités, ce qui se fait en utilisant l' 'xextension de syntaxe gforth pour les littéraux de caractères, et parfois en soustrayant la valeur ASCII de l'espace, qui peut être obtenue en utilisant 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.

Pour terminer, je voudrais dire que j'ai essayé d'utiliser EVALUATE, mais le deuxième programme devient plus grand que les deux présentés ci-dessus. Bref, le voici:

: 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 vous parvenez à jouer au golf assez bas pour déjouer mon s" ..."...approche, allez-y et postez-le comme votre propre réponse.

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

Les deux programmes impriment sur une sortie standard.

Le premier programme Perl contient principalement des caractères ASCII et des sauts de ligne imprimables, et il se termine exactement par un saut de ligne, mais les deux lettres ÿ représentent l'octet 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]

Le second contient principalement des octets non ASCII, y compris plusieurs caractères de contrôle élevé qui sont remplacés par des étoiles dans ce post, et aucune nouvelle ligne du tout:

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

Un hexdump du premier programme avec xxdest:

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

Et un hexdump du deuxième programme est:

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

Dans le deuxième programme, la chaîne entre guillemets (189 octets de long, délimitée par des tildes) est le premier programme entier à l'exception de la nouvelle ligne finale, uniquement codée par bit complétant chaque octet. Le deuxième programme décode simplement la chaîne en complétant chacun des octets, ce que fait l' ~opérateur en perl. Le programme imprime la chaîne décodée suivie d'une nouvelle ligne (lesay méthode ajoute une nouvelle ligne).

Dans cette construction, le décodeur du deuxième programme utilise seulement six caractères ASCII différents, donc le premier programme peut être pratiquement arbitraire, tant qu'il ne contient que des caractères ASCII et exclut ces six caractères. Il n'est pas difficile d'écrire un programme Perl sans utiliser ces cinq caractères. La logique de quine réelle est donc dans le premier programme.

Dans le premier programme, la logique quine utilise un dictionnaire de 11 mots @fet assemble la sortie de ces mots. Les premiers mots répètent la plupart du code source du premier programme. Les autres mots sont des caractères uniques spécifiques. Par exemple, le mot 5 est un tilde, qui est le délimiteur pour le littéral à deux chaînes dans le deuxième programme. La liste des nombres entre parenthèses est la recette pour quels mots imprimer dans quel ordre. Il s'agit d'une méthode de construction générale assez ordinaire pour les quines, la seule torsion dans ce cas est que les premiers mots du dictionnaire sont imprimés avec leurs octets complétés au niveau du bit.

Haskell , 306 + 624 = 930 octets

Programme 1: une fonction anonyme prenant un argument fictif et renvoyant une chaîne.

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

Essayez-le en ligne!

Programme 2: q[[40,...]]à la fin est une fonction anonyme prenant un argument fictif et renvoyant une chaîne.

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

Essayez-le en ligne!

Jeu de caractères 1 (inclut l'espace):

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

Jeu de caractères 2 (inclut la nouvelle ligne):

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

Étant donné que seul l'ensemble 1 contient des caractères non ASCII, leurs octets UTF-8 sont également disjoints.

Comment ça marche

• Le programme 1 est généralement écrit avec des expressions lambda, des espaces et des parenthèses, une utilisation gratuite des fonctions alphanumériques intégrées et avec les données de quine en tant que littéraux de chaîne à la fin.

  • Le code principal du programme 1 est transformé en données littérales de chaîne simplement en l'entourant de guillemets.
    • Pour prendre en charge cela, chaque barre oblique inverse est suivie de aou b, qui forment des séquences d'échappement valides qui font le tour show.
    • Un autre avantage minuscule est que a, bet csont les seules lettres minuscules dont les codes ASCII sont inférieurs à 100, enregistrant un chiffre dans le codage numérique utilisé par le programme 2.
  • Le codage littéral de chaîne du code principal du programme 2 est plus obscurci en utilisant Unicode non ASCII: Chaque caractère a 182 ajoutés à son point de code pour assurer qu'il n'y a pas de chevauchement avec les caractères originaux.
    • 182 était auparavant 128, jusqu'à ce que je réalise que je pouvais abuser du fait que 182 est deux fois la longueur du littéral de chaîne pour le code du programme 1 pour raccourcir le décodage. (En prime, le programme 2 peut utiliser des sauts de ligne.)

• Le programme 2 est généralement écrit avec des équations de fonction de niveau supérieur (à l'exception de la dernière anonyme), des littéraux de caractères et des nombres décimaux, une syntaxe de liste / plage et des opérateurs, et avec les données de quine comme une liste de listes de Ints à la fin.

  • Le code principal du programme 1 est codé sous la forme d'une liste de ses points de code, avec une citation finale.
  • Le code principal du programme 2 est codé comme la liste des points de code du littéral de chaîne utilisé dans le programme 1, toujours décalé vers le haut de 182.

Procédure pas à pas, programme 1

• bet csont les valeurs des littéraux de chaîne pour le programme 2 et 1, respectivement, données comme arguments finaux à l'expression lambda. ()est un argument factice uniquement pour satisfaire la règle de PPCG selon laquelle le programme doit définir une fonction.
• foldr(\a->map pred)b(show()>>c)décode la chaîne ben code de base du programme 2 en lui appliquant map predun nombre de fois égal à la longueur de show()>>c == c++c, ou 182.
• tail(show c)convertit la chaîne cen code de base du programme 1, avec un guillemet double final ajouté.
• :pure bcombine cela dans une liste avec la chaîne b.
• map(map fromEnum)$ convertit les chaînes en listes de points de code.
• `mappend`show(...) sérialise la liste de listes résultante et l'ajoute finalement au code principal du programme 2.

Procédure pas à pas, programme 2

• Le niveau supérieur z~z=[[['@','0'..]!!4..]!!z]est une fonction qui convertit les points de code en caractères (nécessaire pour écrire car tous les caractères ne toEnumsont pas disponibles.)
  • Son argument de point de code est également appelé z. Le marqueur de paresse ~n'a aucun effet dans cette position mais évite un caractère d'espace.
  • ['@','0'..] est une plage de liste de pas en arrière commençant par le code ASCII 64, puis sautant 16 vers le bas à chaque étape.
  • S'appliquer !!4à cela donne un \NULcaractère.
  • Envelopper cela dans une [ ..]plage donne une liste de tous les caractères, qui !!zindexe.
  • Le personnage est finalement enveloppé dans une liste singleton. Cela permet de mapper la fonction zsur des listes en utilisant =<<au lieu de l'indisponible mapet <$>.
• Le niveau supérieur q[x,q]_=z=<<x++q++[34,34]++xest une fonction construisant le programme 1 à partir de la liste des données de quine.
  • xest les données pour le noyau du programme 1 (y compris une double citation finale) et l'intérieur qest les données obscurcies pour le noyau du programme 2. _est un autre argument factice uniquement pour faire de la fonction anonyme finale une fonction au lieu d'une simple chaîne.
  • x++q++[34,34]++x concatène les pièces, y compris deux guillemets doubles avec le code ASCII 34.
  • z=<<construit le programme 1 en mappant zsur la concaténation pour convertir des points de code en caractères.
• La finale q[[40,...]]est une fonction anonyme se combinant qavec les données de quine.

Gelée , _{128 90 87 86 85 79} 16 + 32 = 48 octets

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

Essayez-le en ligne!

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

Essayez-le en ligne!

Le premier programme fait ce qui suit:

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

Cela laisse les chaînes 79,7806,8318,7885,7769,338,115et ỌṘles deux arguments de la chaîne et ils sont implicitement concaténés et imprimés à la fin.

Le deuxième programme calcule le chr( Ọ) de la liste des nombres qui revient OṾ⁾ọṙŒs. Ṙimprime “OṾ⁾ọṙŒs”(avec guillemets) et renvoie l'entrée, en laissant “OṾ⁾ọṙŒs”OṾ⁾ọṙŒsla sortie complète.

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

"lF{3+|3d*HqlJJJQpp2

Essayez-le en ligne!

'5ssTMMMotK-g6.6~Io

Essayez-le en ligne!

Vérifiez-le en ligne!

Comment ils travaillent

"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

Adapté de la réponse> <> de Jo King . Ayant beaucoup plus de commandes alternatives pour la sortie et la répétition, il n'y avait pas besoin de goup , et les deux corps principaux sont devenus beaucoup plus courts.

Une autre différence principale est que je génère la citation de l'adversaire directement en haut de la pile. De cette façon, il était légèrement plus facile de garder l'invariant de quote + my code + opponent code(reversed and shifted).