Produisez un programme A de telle sorte que son exécution dans la langue A produise le programme B et que l'exécution du programme A dans la langue B produise le programme C.

Le programme B, lorsqu'il est exécuté dans la langue B, produit le programme A, et l'exécution du programme B dans la langue A produit le programme C.

Le programme C, lorsqu'il est exécuté dans la langue A ou la langue B , imprime "Mauvaise langue!".

Program | Language | Result
--------|----------|----------
A       | A        | Program B
B       | B        | Program A
A       | B        | Program C
B       | A        | Program C
C       | A        | "Wrong language!" 
C       | B        | "Wrong language!" 

Votre réponse doit utiliser ce modèle:

Langue A / Langue B, {a octets} + {b octets} = {total octets} octets

Programme A:

a code

Programme B:

b code

Programme C:

c code 

La source:

# Language A/Language B, <a bytes> + <b bytes> = <total bytes> bytes

Program A:

    a code
Program B:

    b code
Program C:

    c code

• Aucun de ces programmes ne devrait recevoir de contribution.
• Différentes versions de la même langue comptent comme des langues différentes. (bien que cela soit découragé car cela conduit à des solutions ennuyeuses)
• Les langues A et B doivent être distinctes.
• Vous ne devez pas lire votre propre code source à partir d'un fichier. Les programmes peuvent ne pas être vides
• Des échappatoires standard s'appliquent.

Astuces

• C ++ et [Python / Bash / autres #langages commentés] sont de bons combos car vous pouvez définir des macros qu'une langue peut ignorer

Il s'agit de code-golf , donc la plus petite somme des octets compte pour les programmes A et B.

Befunge-98 (PyFunge) / > <> , 123 + 123 = 266 250 246 octets

"81!#.#vp00g>:#,_j+4<.=1l5v!o#!g00
g00<<<<<>0!#[f8+1!#.48*k'Wrong language!<o>[f@,kep.#!0a'00g!#o# \!gff+k,@,k*8ba$$ #o#!a"

Essayez-le dans Befunge-98! , Essayez - le dans> <>!

"00g!#o!v5l1=.<4+j_,#:>g00pv#.#!18
g00<<<<<>0!#[f8+1!#.48*k'Wrong language!<o>[f@,kep.#!0a'00g!#o# \!gff+k,@,k*8ba$$ #o#!a"

Essayez-le dans> <>! , Essayez - le dans Befunge-98!

"a0!#.pek,@f[>o<!egaugnal gnorW

Essayez-le dans Befunge-98! Essayez-le dans> <>!

Comment ça marche:

La deuxième ligne des deux programmes est identique et remplit la même fonction pour les deux langues. Une fois entré à gauche de la<<<< , il imprime toute la deuxième ligne. En entrant à droite de ceux-ci, imprimez le programme C.

Lorsque la première ligne est exécutée dans la mauvaise langue, elle entre par la section de production du programme C. Sinon, il imprime la ligne supérieure à l'envers avec le" l'avant et entre dans la deuxième section de production de ligne.

Première ligne

"81!#.#vp00g>:#,_j+4<.=1l5v!o#!g00

><>:
" Wrapping string literal over the first line
 81!#.  Jumps the pointer to the Program C producer

Befunge-98:
" Wrapping string literal
 81!#.  Pushes 8,0 (! inverts number, # skips over .)
      #v Skip over the exit
        p00g Pops the excess 8,0 and space and gets the " from 0,0
            >:#,_ Classic print until stack is empty
       v         j+4< Skips back to the exit and goes to the second line

"00g!#o!v5l1=.<4+j_,#:>g00pv#.#!18

><>:
" Wrapping string literal
 00g!# Gets the " from 0,0
      o!v5l1=. Print until the stack is empty and jump to the second line

Befunge-98:

" Wrapping string literal
 00g Gets the " from 0,0
    !#o!v Skip the instruction o and go to Program C producer

Deuxième ligne:

g00<<<<<>0!#[f8+1!#.48*k'Wrong language!<o>[f@,kep.#!0a'00g!#o# $$00gff+k,@,k*9aa$$ #o#!a"

><>: Second line producer
g00<<<<< Get the " from cell 0,0
        ......      " Wrapping string literal over the stack
               #o#!a  Print newline and the stack and exit
Program C producer:
       >0!#[        Clear stack
            f8+1!#. Jump to cell 22,1
                   .....'...'   Push program C to the stack
                             00g Get " from cell 0,0
                                !#o# Print stack until empty

Befunge-98: Second line producer

g00<<<<< Get the " from cell 0,0
        ......              " Wrapping string literal
                       #o#!a  Skip over instruction o
                     $$       Pop the excess characters
                  90a Push a newline and 90
               @,k      Execute , instruction (print) 90+1 times, printing second line

Program C producer:
        >0!#[ Push 1 and skip [
             f8+1!#. Push 22, 0 and skip .
                    48*k'...' Execute ' instruction 32 times, pushing program C
                         ...'00g!#o# Push 0 and skip the instruction o
                                     \! Convert excess values to two 0s
                                       g Get " from cell 0,0
                                          ff+ Push 30
                                             k, Execute , 30+1 times, printing program C
                                               @ Exit program

Programme C

"a0!#.pek,@f[>o<!egaugnal gnorW

><>:
" Wrapping string literal
 a0!#. Jump to cell 10,0
           f[ Create a new stack with only the top 15 elements
             >o< Print stack

Befunge-98:
" Wrapping string literal
 a0!#. Push 10,1
      p Pop 10,1 and excess space
       ek,@ Push 14 and execute , 14+1 times and exit the program

JavaScript (ES6) / Python 3, 264 + 258 = 522 octets

Programme A:

a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";c="1//2;alert=print\nalert('Wrong language!')";1//2;print(c);'''
console.log(b,...[a,b,c].map(uneval))//'''

Programme B:

a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";c="1//2;alert=print\nalert('Wrong language!')";1//2;'''
print=_=>console.log(c)//'''
print(a%(a,b,c))

Programme C:

1//2;alert=print
alert('Wrong language!')

Probablement golfable ...

Explication JavaScript

Programme A:

// Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

// Ignore this line:
1//2;print(c);'''

// Print the Python program (b), replacing the "%s"s with the raw forms of a, b, and c:
console.log(b,...[a,b,c].map(uneval))//'''

Programme B:

// Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

// Ignore this line:
1//2;'''

// Define a function `print` which prints `c` (the "Wrong language!" program):
print=_=>console.log(c)//'''

// Call `print`, ignoring the argument (which is NaN):
print(a%(a,b,c))

Programme C:

// Ignore this line:
1//2;alert=print

// Alert "Wrong language!":
alert('Wrong language!')

Explication Python

Programme A:

# Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

# Print `c` (the "Wrong language!" program):
1//2;print(c);

# Ignore this part:
'''
console.log(b,...[a,b,c].map(uneval))//'''

Programme B:

# Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

# Ignore this part:
1//2;'''
print=_=>console.log(c)//'''

# Print the JS program (a), replacing the "%r"s with the raw forms of a, b, and c:
print(a%(a,b,c))

Programme C:

# Set `alert` to the function `print`:
1//2;alert=print

# Call this function on "Wrong language!":
alert('Wrong language!')

Python 3 + JavaScript (Rhino), 171 + 171 = 342 octets

Programme A (affiche le programme B en Python 3, le programme C en JavaScript; notez le retour à la ligne):

s="'";d='"';r=['print("s="+d+s+d+";d="+s+d+s+";r=["+s+r[1]+s+","+s+r[0]+s+"];eval(r[([11]+[0])[1]])")','print("print("+d+"Wrong language!"+d+")")'];eval(r[([11]+[0])[1]])

Programme B (affiche le programme A en JavaScript, le programme C en Python; notez le retour à la ligne):

s="'";d='"';r=['print("print("+d+"Wrong language!"+d+")")','print("s="+d+s+d+";d="+s+d+s+";r=["+s+r[1]+s+","+s+r[0]+s+"];eval(r[([11]+[0])[1]])")'];eval(r[([11]+[0])[1]])

Programme C (affiche "Wrong language!" Dans l'une ou l'autre langue; possède également une nouvelle ligne de fin, qui ne compte pas dans la partition):

print("Wrong language!")

Notez que j'utilise ici un dialecte inhabituel de JavaScript. Les gens utilisent normalement des implémentations de navigateur, mais celles-ci ont des problèmes avec la sortie, le faisant de manière étrange (en utilisant alert). J'utilise le package Ubuntu rhinoqui est une implémentation JavaScript "hors ligne" avec un ensemble différent de bibliothèques implémentées dans un navigateur typique (il est conçu comme un langage de script intégrable); ceci est remarquable en ce qu'il fournit une printinstruction dans le même style que, par exemple, Python 3.

Il s'agit d'un «vrai polyglotte» dans le sens où les deux langues exécutent les mêmes calculs, dans le même ordre, leur donnant le même sens. Ils ont tous les deux le même AST (et il est assez trivial de créer une quine polyglotte Python 3 + JavaScript en réduisant ce programme). Il n'y a pas de code spécifique à une langue, ce qui m'aide à réduire la longueur. Soit dit en passant, vous devez utiliser Python 3 pour pouvoir utiliser des points-virgules pour séparer les instructions (si vous utilisez des sauts de ligne, vous devez échapper aux sauts de ligne).

Le programme commence par définir des chaînes set dqui contiennent respectivement un guillemet simple et un guillemet double. Cela permet de générer des citations sans avoir à les mentionner plus loin dans le code source, évitant ainsi les problèmes d'échappement (qui semblent souvent être un problème avec les quines; la principale raison pour laquelle je réponds à tant de problèmes de quine dans Underload est que ses chaînes s'emboîtent) .

Le cœur du programme est le tableau rqui contient le corps principal des deux programmes utilisés par le défi; l'un des programmes (celui qui vient en premier dans le programme A et le deuxième dans le programme B) est une quasi-quine qui sort simplement le programme original en concaténant des morceaux ensemble (pris principalement de rlui-même, avec quelques littéraux de chaîne), et le d'autres programmes imprime C. Afin de faire du programme pas un vrai quine (ce qui rendrait impossible de détecter que nous fonctionnions dans la mauvaise langue), les éléments de rsont imprimés dans l'ordre inverse; r[0]dans le programme A est r[1]dans le programme B, et vice versa.

Enfin, tout ce qui est nécessaire est de mettre à jour evall'élément correct de r. Ceci est accompli en utilisant l'expression ([11]+[0])[1]qui produit une valeur différente en Python 3 et en JavaScript. Les deux langues l'analysent de manière identique, mais elles ont des idées différentes de ce que l'addition fait aux listes:

• Lorsque Python 3 s'ajoute [11]à [0], il obtient [11, 0](concaténant les listes), puis prendre le deuxième élément de list ( [1]) nous donne l'entier 0.

• Lorsque JavaScript s'ajoute [11]à [0], il obtient "110"(concaténant les représentations de chaîne des listes), puis prendre le deuxième caractère de la chaîne ( [1]) nous donne la chaîne "1", que JavaScript est très heureux d'utiliser comme index dans une liste.

Par conséquent, Python 3 exécute le premier élément de rdans les deux programmes (produisant la quasi-quine lors de l'exécution du programme A et l'impression du programme C lors de l'exécution du programme B); JavaScript exécute le deuxième élément et traite donc le programme A et le programme B dans le sens inverse.

Par ailleurs, si vous exécutez le programme A dans Ruby, il imprimera le programme B, sauf sans retour à la ligne. Si vous exécutez le programme B dans Ruby, il imprimera le programme C, sauf sans retour à la ligne. En d'autres termes, cette solution fonctionne presque avec un ensemble de langues différent, échangeant Python 3 pour Ruby (la seule raison pour laquelle je ne supprime pas simplement la nouvelle ligne du programme B pour obtenir un score de 341 est que l'incohérence de la nouvelle ligne dans le programme C disqualifierait la soumission).

(Je travaillais sur un "vrai polyglotte" comme celui-ci pour une raison différente, que j'ai maintenant présentée comme un défi, et j'ai réalisé que les techniques pouvaient également être adaptées à celui-ci.)

C / Python, 733 octets + 733 octets = 1466 octets

Programme A:

#define int char*
int
a1="#define print(X) main(){printf(d,13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,b1,13,b2);}";
int
a2="print(c%(13,34,34))";
int
b1="#define print(X) main(){printf(c,13,34,34);};";
int
b2="print(d%(13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,a1,13,a2))";
int
c="#define print(a) main(){puts(a);}%cprint(%cWrong language!%c)";
int
d="#define int char*%cint%ca1=%c%s%c;%cint%ca2=%c%s%c;%cint%cb1=%c%s%c;%cint%cb2=%c%s%c;%cint%cc=%c%s%c;%cint%cd=%c%s%c;%c%s%c%s";
#define print(X) main(){printf(d,13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,b1,13,b2);}
print(c%(13,34,34))

Programme B:

#define int char*
int
a1="#define print(X) main(){printf(d,13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,b1,13,b2);}";
int
a2="print(c%(13,34,34))";
int
b1="#define print(X) main(){printf(c,13,34,34);};";
int
b2="print(d%(13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,a1,13,a2))";
int
c="#define print(a) main(){puts(a);}%cprint(%cWrong language!%c)";
int
d="#define int char*%cint%ca1=%c%s%c;%cint%ca2=%c%s%c;%cint%cb1=%c%s%c;%cint%cb2=%c%s%c;%cint%cc=%c%s%c;%cint%cd=%c%s%c;%c%s%c%s";
#define print(X) main(){printf(c,13,34,34);};
print(d%(13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,a1,13,a2))

Programme C:

#define print(a) main(){puts(a);}
print("Wrong language!")

J'ai utilisé votre conseil d'utilisation de C / C ++ avec Python. Pas très concis, mais toujours qualificatif je suppose.

Python 2 / Retina, 550 + 645 = 1373 1254 1221 1195 octets

Je ne sais pas trop si les parties unichret replacepeuvent être jouées davantage. J'ai essayé d'utiliser Python 3, mais beaucoup est perdu en devant ajouter des parenthèses et les gérer. J'ai essayé de régler R=unicode.replaceet d'utiliser cela, mais la sortie est foirée.

Notez que Retina a un retour à la ligne de fin dans sa sortie par défaut, et cela n'est pas inclus dans les programmes. Si quelqu'un dit que je dois le retirer, cela peut être fait trivialement. En outre, le code Python fonctionne dans repl.it, mais il n'est pas garanti qu'il fonctionne sur Ideone.com.

Notez également que les nouvelles lignes de début et de fin sont significatives dans le code ci-dessous.

Programme A (Python 2): 638 587 566 550 octets (UTF-8)

Python 2 , rétine

U=unichr;s=U(39)*3;_=u'''\n#U=unichr;s=U(39)*3;_=u%s.replace(U(9),U(96));print _%%(s+_+s).replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179)).replace(U(183),U(184)).replace(U(182),U(183))#|¶#·print"Wrong language!"·#?.*t|"·¶#{2}|^.¶\n#1 #\n\n#T ²-¹ _o  [^¹]\nn=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n\n'''.replace(U(9),U(96));print _%(s+_+s).replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179)).replace(U(183),U(184)).replace(U(182),U(183))#|
#¶print"Wrong language!"¶#?.*t|"¶
#{2}|^.

Programme B (rétine): 735 667 655 645 octets (ISO 8859-1)

Rétine , Python 2

#U=unichr;s=U(39)*3;_=u'''\n#U=unichr;s=U(39)*3;_=u%s.replace(U(9),U(96));print _%%(s+_+s).replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179)).replace(U(183),U(184)).replace(U(182),U(183))#|·#¸print"Wrong language!"¸#?.*t|"¸·#{2}|^.·\n#1   #\n\n#T ³-¹ _o  [^¹]\nn=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n\n'''.replace(U(9),U(96));print _%(s+_+s).replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179)).replace(U(183),U(184)).replace(U(182),U(183))#|¶#·print"Wrong language!"·#?.*t|"·¶#{2}|^.¶
#1`#

#T`²-¹`_o`[^¹]
n=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n

Programme C:

Python 2 , rétine

Cela peut en fait être raccourci en utilisant #!`W.*!au lieu des deux dernières lignes, mais cela allonge A et B, car avoir `une ligne où il n'y en avait pas signifie que je dois le gérer différemment (parce que le premier backtick d'une ligne dans Retina est un délimiteur de configuration).

print"Wrong language!"
#?.*t|"

Explication:

Programme C:

                        # Retina: replace nothing with the Python code string
print"Wrong language!"  # >> code is executed if run in Python
#?.*t|"                 # Comment w/ '?' for Retina to skip, then replace up to the 't',
                        #    as well as any quotation marks, with nothing

J'ai écrit le programme C en premier lors de ma première tentative et je l'ai gardé pratiquement le même. En Python, il imprime la chaîne et ignore le commentaire. Dans la rétine, il ne remplace rien par print"Wrong language!"puis supprime les pièces autour Wrong language!.

Pour mieux comprendre les programmes complexes, regardons les versions simplifiées:

Programme A (simplifié):

print"\n#PYTHON\n#1`#\n\n#T`²-¹`_o`[^¹]\nn=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n\n"#|
#¶print"Wrong language!"¶#?.*t|"¶
#{2}|^.

Quand j'ai recommencé à zéro, j'ai utilisé le PYTHON bit comme espace réservé pour le code qui devrait imprimer le programme A. Cette version plus simple a permis d'expliquer plus facilement comment le programme B et le programme C seraient imprimés.

Le printet tout à l'intérieur est ce qui imprime le programme B, mais d'abord, voyons comment le programme C est imprimé, car c'est simple. Après l' print"..."est #|. Cette astuce a sauvé des charges de difficulté que j'ai rencontrées lors de ma première tentative. Cela permet à Retina de ne rien remplacer par la 2e ligne, qui sera le programme C, sauf qu'il y a un #devant. Les 2 dernières lignes suppriment cela en premier #. J'avais l'habitude #{2}d'empêcher la scène de supprimer toutes les occurrences de #. Je ne peux pas utiliser#1`# comme je l'ai utilisé dans le programme B, car cela provoque des problèmes pour avoir ce backtick dans la première ligne du programme A.

Ce qui m'amène à ma prochaine tâche, l'impression du programme B. Vous avez peut-être remarqué une autre différence par rapport au code réel. Il n'y a pas de backticks dans le code réel, puisque je les ai remplacés par des tabulations. J'ai dû remplacer un caractère, car tout backtick ferait du code précédent une chaîne de configuration dans Retina, ce qui rendrait la syntaxe invalide. J'ai choisi des onglets car ils sont visibles et le point de code est un seul chiffre ( 9). Le code imprime le programme B comme indiqué dans la version simplifiée ci-dessous.

Programme B:

#PYTHON
#1`#

#T`²-¹`_o`[^¹]
n=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n

Les deux premières lignes ne remplaceront rien par le code Python, mais par un #devant et certains caractères légèrement différents. Cette partie est omise pour plus de clarté. L'étape suivante supprime cela en premier #. Ensuite, j'utilise une étape #T`²-¹`_o`[^¹]de translittération (T) pour annuler certaines des replaceopérations vues dans le programme complet A. L'utilisation de cette étape est un moyen de produire un pilcrow littéral ¶dans la rétine, qui pourrait sinon être impossible.¹ Il remplace ·par ¶, et ³par ². Les occurrences de ¹resteront les mêmes car elles sont ignorées [^¹].

Programme A:

Des nouvelles lignes et des onglets ont été ajoutés pour plus de lisibilité.

U=unichr;s=U(39)*3;

_=u'''
    \n#U=unichr;s=U(39)*3;

    _=u%s.replace(U(9),U(96));

    print _%%(s+_+s)
    .replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179))
    .replace(U(183),U(184)).replace(U(182),U(183))#|

    ¶#·print"Wrong language!"·#?.*t|"·
    ¶#{2}|^.
    ¶

    \n#1    #\n\n#T ²-¹ _o  [^¹]\nn=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n\n'''

.replace(U(9),U(96));

print _%(s+_+s)
.replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179))
.replace(U(183),U(184)).replace(U(182),U(183))#|

#¶print"Wrong language!"¶#?.*t|"¶
#{2}|^.

Cela suit la structure générale du quine Python suivant:

_='_=%r;print _%%_';print _%_

Lorsque vous ajoutez des éléments avant ou après, vous devez également les mettre dans la chaîne.

U=unichr;_='U=unichr;_=%r;print(_%%_).replace('','')';print(_%_).replace('','')

Je voulais utiliser une chaîne entre guillemets pour faciliter l'inclusion de guillemets (en évitant l'utilisation de barres obliques inverses). s=U(39)*3;est la chaîne '''. J'ai également utilisé à la %splace de %r, afin d'éviter certains problèmes avec les sauts de ligne ou d'autres caractères échappés avec des barres obliques inverses.

U=unichr;s=U(39)*3;_='''U=unichr;s=U(39)*3;_=%s;print(s+_%%_+s).replace('','')''';print(s+_%_+s).replace('','')

Alors maintenant, les remplacements. Le premier remplacement .replace(U(9),U(96));est là pour remplacer les onglets par les astuces que nous voyons dans le programme B. Ce remplacement est effectué avant le formatage des chaînes, car les onglets doivent rester des onglets dans le programme A. Les autres remplacements consistent simplement à éviter d'utiliser certains caractères dans le 2e ligne du programme B:

.replace(U(10),U(92)+'n')   # Replace newlines with a backslash and 'n', for B to print A.
.replace(U(96),U(9))        # Replace backticks with tabs for the first part of B.
.replace(U(178),U(179))     # Replace '²' with '³', which will be undone with B's T stage
.replace(U(183),U(184))     # Replace '·' with '¸', which will be undone with B's T stage
.replace(U(182),U(183))     # Replace '¶' with '·', which will be undone with B's T stage

Ces trois derniers remplacements anticipent l'étape de translittération dans le programme B, afin d'empêcher que ces caractères soient supprimés ou translittérés alors qu'ils ne devraient pas l'être.

La seule autre partie du code est le code du programme B qui est essentiellement copié caractère par caractère, à l'exception des modifications dues aux remplacements.

¹ Merci à Martin pour son conseil sur la sortie d'un littéral ¶en rétine. Cela a rendu tout tellement plus facile.

Befunge / Python, 381 + 485 259 + 345 229 + 304 = 533 octets

Programme A: Essayez à Befunge | Essayez en Python

#>21g::35*:*::":"%\>:#$":"%#\ \#%":"/#::$#-g#1\_#+\#5:#5_v
#v"50g"g12"'<:#>!#,_@<'tnirp"g12">:#,_@"+55"print "::g12$<
#>21g"Wrong language!"21g"g05"21g"[+5+5:]"21g"+55>#">:#,_@
print'''print'<@_,#!>#:<'"Wrong language!"[+5+5:]'''

Programme B: Essayez en Python | Essayez à Befunge

#>55+"]:5+5+["50g"!egaugnal gnorW"50g"'<:#>!#,_@<'tnirp">:#,_@
print """#>21g::35*:*::":"%\>:#$":"%#\ \#%":"/#::$#-g#1\_#+\#5:#5_v
#v"50g"g12"'<:#>!#,_@<'tnirp"g12">:#,_@"+55"print "::g12$<
#>21g"Wrong language!"21g"g05"21g"[+5+5:]"21g"+55>#">:#,_@
print'''print'<@_,#!>#:<'"Wrong language!"[+5+5:]'''"""

Programme C: Essayez à Befunge | Essayez en Python

print'<@_,#!>#:<'"Wrong language!"[+5+5:]

Explication

Programme C: Cela repose sur le fait que Befunge-93 ignore les instructions non prises en charge, donc pendant que l' pécriture inoffensive d'un zéro à 0; 0, le reste du printest ignoré jusqu'à l' <instruction qui inverse la direction. Puis, de droite à gauche, le +5+5pousse un 10 (saut de ligne) sur la pile, suivi de la chaîne de message, puis une séquence de sortie standard est exécutée pour écrire la chaîne. En Python, il s'agit simplement d'imprimer deux littéraux de chaîne qui sont concaténés ensemble, mais le premier (contenant le code Befunge) est coupé par la référence du tableau à la fin ( [+5+5:]).

Programme B: La première ligne est une séquence Befunge assez basique pour imprimer le programme C. La seule chose intéressante est la façon dont elle génère des guillemets en utilisant 50g(c'est-à-dire en lisant le caractère de la mémoire) qui est plus efficace que le calcul du code ASCII. Le #>(un pont sur l'instruction de direction) est essentiellement un nop qui empêche le code d'être vu par Python puisqu'il #s'agit du caractère de commentaire Python. L'interprétation Python commence à la ligne deux et imprime simplement une chaîne multiligne contenant le code source du programme A.

Programme A: en Python, les trois premières lignes sont à nouveau ignorées car elles commencent par #, tandis que la dernière ligne imprime simplement le programme C. Le code Befunge serpente d'avant en arrière sur les trois premières lignes, créant la source du programme B sur la pile dans le sens inverse. Il commence par trois guillemets, puis une séquence qui fait une copie de la source du programme A, et enfin ce qui est essentiellement une chaîne codée en dur avec l'ouverture print """et la première ligne de code Befunge. Il suffit alors de l'écrire avec une séquence de sortie standard.

Quelques points de discorde:

1. On m'a dit qu'un quine utilisant la gcommande n'est pas considéré comme un quine approprié en ce qui concerne cette communauté. Je ne sais pas si cette règle s'appliquerait également à ce défi, mais si c'est le cas, cette réponse pourrait ne pas être considérée comme une solution appropriée non plus.

2. Bien que j'ai dit que Befunge-93 ignore les instructions non prises en charge, cela n'est pas techniquement défini dans la spécification, et vous devrez utiliser l' -qoption de ligne de commande (silencieuse) dans l'interpréteur de référence pour éviter les avertissements dans le programme C. La plupart des autres interprètes le feront être bien, cependant, mais certains des plus flocons pourraient potentiellement planter. Notez également que Befunge-98 réfléchit sur les instructions non prises en charge, donc un interpréteur 98 bouclera indéfiniment.

Perl / JavaScript, 176 octets + 176 octets = 352 octets

Ne pensez pas que je peux partager 52 octets hors du mécanisme sous-jacent pour la prime, mais j'ai aimé construire cela. Je pense que ce que j'ai produit répond aux critères ...

Programme A:

$P=1;$_='$L=eval("printf=console.log;J=``;q=_=>_+J;2")||1;$P?printf(q`$P=%s;$_=%s%s%s;eval($_)`,$P=$P==$L?J?2:1:0,$q=J?h^O:atob("Jw"),$_,$q):printf("Wrong language!")';eval($_)

Programme B:

$P=2;$_='$L=eval("printf=console.log;J=``;q=_=>_+J;2")||1;$P?printf(q`$P=%s;$_=%s%s%s;eval($_)`,$P=$P==$L?J?2:1:0,$q=J?h^O:atob("Jw"),$_,$q):printf("Wrong language!")';eval($_)

Programme C:

$P=0;$_='$L=eval("printf=console.log;J=``;q=_=>_+J;2")||1;$P?printf(q`$P=%s;$_=%s%s%s;eval($_)`,$P=$P==$L?J?2:1:0,$q=J?h^O:atob("Jw"),$_,$q):printf("Wrong language!")';eval($_)

Explication

Utilise ma polyquine Perl / JavaScript comme base mais définit une variable supplémentaire $Pqui contrôle le programme à générer. Utilise la vérification qui +[]est véridique en Perl, mais fausse en JavaScript.