Produzieren Sie ein Programm A so, dass das Ausführen in Sprache A Programm B und das Ausführen von Programm A in Sprache B Programm C erzeugt.

Wenn Programm B in Sprache B ausgeführt wird, wird Programm A erstellt, und wenn Programm B in Sprache A ausgeführt wird, wird Programm C erstellt.

Programm C gibt "Falsche Sprache!" Aus , wenn es in Sprache A oder Sprache B ausgeführt wird.

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!" 

Ihre Antwort sollte diese Vorlage verwenden:

Sprache A / Sprache B, {a Bytes} + {b Bytes} = {Gesamtbytes} Bytes

Programm A:

a code

Programm B:

b code

Programm C:

c code 

Quelle:

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

Program A:

    a code
Program B:

    b code
Program C:

    c code

• Keines dieser Programme sollte Eingaben annehmen.
• Verschiedene Versionen derselben Sprache zählen als verschiedene Sprachen. (obwohl davon abgeraten wird, weil es zu langweiligen Lösungen führt)
• Die Sprachen A und B müssen unterschiedlich sein.
• Sie dürfen keinen eigenen Quellcode aus einer Datei lesen. Programme dürfen nicht leer sein
• Es gelten Standardlücken.

Hinweise

• C ++ und [Python / Bash / andere #kommentierte Sprachen] sind gute Kombinationen, da Sie Makros definieren können, die eine Sprache ignorieren kann

Dies ist Codegolf , daher gewinnt die kleinste Summe der Byte-Zählungen Programm A und B.

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

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

Probieren Sie es in Befunge-98! , Versuchen Sie es in> <>!

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

Probieren Sie es in> <>! , Versuchen Sie es in Befunge-98!

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

Probieren Sie es in Befunge-98! Probieren Sie es in> <>!

Wie es funktioniert:

Die zweite Zeile in beiden Programmen ist identisch und hat für beide Sprachen die gleiche Funktion. Bei der Eingabe von links nach <<<<wird die gesamte zweite Zeile gedruckt. Wenn Sie rechts von diesen eingeben, drucken Sie Programm C.

Wenn die erste Zeile in der falschen Sprache ausgeführt wird, wird sie durch den Programm-C-Erzeugungsabschnitt eingegeben. Andernfalls wird die oberste Zeile mit "der Vorderseite nach hinten gedruckt und in den zweiten Zeilenproduktionsabschnitt eingegeben.

Erste Linie

"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

Zweite Reihe:

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

Programm 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 Byte

Programm 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))//'''

Programm 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))

Programm C:

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

Wahrscheinlich golfen ...

JavaScript Erklärung

Programm 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))//'''

Programm 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))

Programm C:

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

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

Python Erklärung

Programm 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))//'''

Programm 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))

Programm 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 Byte

Programm A (gibt Programm B in Python 3, Programm C in JavaScript aus; beachten Sie den Zeilenumbruch):

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

Programm B (gibt Programm A in JavaScript aus, Programm C in Python; Zeilenumbruch beachten):

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

Programm C (gibt in beiden Sprachen "Falsche Sprache!" Aus; hat auch eine abschließende Zeile, die in der Partitur nicht berücksichtigt wird):

print("Wrong language!")

Beachten Sie, dass ich hier einen ungewöhnlichen JavaScript-Dialekt verwende. Normalerweise verwenden die Benutzer Browserimplementierungen, aber diese haben Probleme mit der Ausgabe und tun dies auf seltsame Weise (mit alert). Ich verwende das Ubuntu-Paket rhino, eine "Offline" -Javascript-Implementierung mit einer anderen Gruppe von Bibliotheken, die in einem typischen Browser implementiert sind (es ist als einbettbare Skriptsprache gedacht). Dies ist insofern bemerkenswert, als es eine printAnweisung im gleichen Stil wie beispielsweise Python 3 bereitstellt .

Dies ist ein "echter Polyglott" in dem Sinne, dass beide Sprachen die gleichen Berechnungen in der gleichen Reihenfolge ausführen und ihnen die gleiche Bedeutung geben. Sie haben beide den gleichen AST (und es ist ziemlich trivial, ein Python 3 + JavaScript-Polyglott-Quine durch Reduzieren dieses Programms zu erstellen). Es gibt keinen Code, der für eine Sprache spezifisch ist, was mir hilft, die Länge zu reduzieren. Übrigens müssen Sie Python 3 verwenden, damit Sie die Anweisungen mit Semikolons trennen können (wenn Sie Zeilenumbrüche verwenden, müssen Sie die Zeilenumbrüche umgehen).

Das Programm beginnt mit der Definition von Strings s , und ddie halten einen Apostroph und Anführungszeichen sind. Dies ermöglicht die Ausgabe von Anführungszeichen, ohne sie später im Quellcode erwähnen zu müssen, und vermeidet Probleme mit dem Escaping (was häufig ein Problem mit Quines zu sein scheint; der Hauptgrund, warum ich so viele Quine-Probleme in Underload beantworte, ist, dass die Strings verschachtelt sind). .

Das Herzstück des Programms ist das Array, rdas den Hauptteil der beiden von der Challenge verwendeten Programme enthält. Eines der Programme (das erste in Programm A und das zweite in Programm B) ist ein Quine-Programm, bei dem das ursprüngliche Programm einfach durch Verketten von Stücken (die größtenteils aus sich rselbst stammen, mit einigen Zeichenfolgenliteralen) ausgegeben wird anderes Druckprogramm C. Um das Programm nicht zu einem echten Quine zu machen (was es unmöglich machen würde, zu erkennen, dass wir in der falschen Sprache liefen), werden die Elemente von rin umgekehrter Reihenfolge gedruckt;r[0]in Programm A ist r[1]in Programm B und umgekehrt.

Schließlich ist es nur evalerforderlich, das richtige Element von zu verwenden r. Dies geschieht mit dem Ausdruck ([11]+[0])[1], der in Python 3 und JavaScript einen anderen Wert erzeugt. Beide Sprachen analysieren es identisch, aber sie haben unterschiedliche Vorstellungen darüber, was das Hinzufügen zu Listen bewirkt:

• Wenn Python 3 addiert [11]zu [0], wird es [11, 0](die Listen Verketten) und anschließend das zweite Element der Liste nehmen ([1] ) gibt uns die ganze Zahl 0.

• Wenn JavaScript fügt [11]an [0], wird es "110"(die Verkettung von Zeichenfolgendarstellungen von den Listen), und dann das zweite Zeichen des Strings nehmen ( [1]) gibt uns die Zeichenfolge "1", die JavaScript ganz zufrieden ist als ein Index in eine Liste zu verwenden.

Aus diesem Grund führt Python 3 das erste Element rin beiden Programmen aus (wobei bei Ausführung von Programm A fast ein Quine erzeugt und bei Ausführung von Programm B Programm C gedruckt wird). JavaScript führt das zweite Element aus und behandelt daher Programm A und Programm B umgekehrt.

Übrigens, wenn Sie Programm A in Ruby ausführen, wird Programm B gedruckt, außer ohne nachfolgende Zeilenumbrüche. Wenn Sie Programm B in Ruby ausführen, wird Programm C mit Ausnahme einer nachgestellten Zeile gedruckt. Mit anderen Worten, diese Lösung funktioniert beinahe mit einem anderen Satz von Sprachen und tauscht Python 3 gegen Ruby aus (der einzige Grund, warum ich nicht einfach die neue Zeile aus Programm B lösche, um eine Punktzahl von 341 zu erhalten, ist die Inkonsistenz der neuen Zeile in Programm C würde die Einreichung disqualifizieren).

(Ich habe aus einem anderen Grund an einem "echten Polyglot" wie diesem gearbeitet, den ich jetzt als Herausforderung gepostet habe, und erkannte, dass die Techniken auch an diesen angepasst werden können.)

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

Programm 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))

Programm 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))

Programm C:

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

Ich habe Ihren Hinweis verwendet, C / C ++ mit Python zu verwenden. Ich nehme an, es ist nicht sehr präzise, ​​aber es ist immer noch qualifizierend.

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

Ich bin nicht ganz sicher, ob die unichrund replaceTeile mehr Golf gespielt werden können. Ich habe versucht, Python 3 zu verwenden, aber viel geht verloren, wenn ich Klammern hinzufügen und damit umgehen muss. Ich habe versucht, das einzustellen R=unicode.replaceund zu verwenden, aber die Ausgabe wird durcheinander gebracht.

Beachten Sie, dass die Ausgabe von Retina standardmäßig eine nachgestellte Newline enthält, die in den Programmen nicht enthalten ist. Wenn jemand sagt, dass ich es entfernen muss, kann das trivial gemacht werden. Der Python-Code funktioniert auch in repl.it, kann jedoch nicht für Ideone.com garantiert werden.

Beachten Sie auch, dass führende und nachfolgende Zeilenumbrüche im folgenden Code von Bedeutung sind.

Programm A (Python 2): 638 587 566 550 Byte (UTF-8)

Python 2 , Retina

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}|^.

Programm B (Retina): 735 667 655 645 Byte (ISO 8859-1)

Retina , 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

Programm C:

Python 2 , Retina

Dies kann durch die Verwendung #!`W.*!der letzten beiden Zeilen kürzer gemacht werden , aber dies verlängert A und B, da `eine Zeile, in der es keine gab, anders behandelt werden muss (weil das erste Backtick in einer Zeile in der Netzhaut) ist ein Konfigurationsbegrenzer).

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

Erläuterung:

Programm 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

Bei meinem ersten Versuch habe ich zuerst Programm C geschrieben und es größtenteils beibehalten. In Python wird die Zeichenfolge gedruckt und der Kommentar ignoriert. In der Netzhaut ersetzt es nichts durch print"Wrong language!"und entfernt dann die herumliegenden Teile Wrong language!.

Schauen wir uns zum besseren Verständnis der komplexen Programme die vereinfachten Versionen an:

Programm A (vereinfacht):

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}|^.

Als ich von vorne anfing, benutzte ich das PYTHONBit als Platzhalter für den Code, der Programm A drucken sollte. Diese einfachere Version machte es einfacher zu erklären, wie sowohl Programm B als auch Programm C gedruckt werden würden.

Das printund alles drin ist das, was Programm B druckt, aber zuerst wollen wir sehen, wie Programm C gedruckt wird, denn das ist einfach. Nach dem print"..."ist #|. Dieser Trick ersparte mir jede Menge Schwierigkeiten, die ich bei meinem ersten Versuch hatte. Auf diese Weise kann Retina nichts durch die zweite Zeile ersetzen, die Programm C sein wird, es sei denn, es steht eine #voran. Die letzten 2 Zeilen entfernen diese zuerst #. Früher habe ich #{2}die Bühne daran gehindert, alle Vorkommen von zu entfernen #. Ich kann nicht so verwenden, #1`#wie ich es in Programm B verwendet habe, da es Probleme verursacht, diesen Backtick in der ersten Zeile von Programm A zu haben.

Das bringt mich zu meiner nächsten Aufgabe, dem Drucken von Programm B. Möglicherweise haben Sie einen weiteren Unterschied zum tatsächlichen Code festgestellt. Der aktuelle Code enthält keine Backticks, da ich sie durch Tabulatoren ersetzt habe. Ich musste ein Zeichen ersetzen, da jeder Backtick den früheren Code zu einer Konfigurationszeichenfolge in Retina machen würde, wodurch die Syntax ungültig würde. Ich habe Registerkarten ausgewählt, weil sie sichtbar sind und der Codepunkt eine einzelne Ziffer ist ( 9). Der Code druckt Programm B wie in der vereinfachten Version unten gezeigt.

Programm B:

#PYTHON
#1`#

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

Die ersten beiden Zeilen ersetzen nichts mit dem Python-Code, sondern mit einem #vorangestellten und einigen leicht abweichenden Zeichen. Dieser Teil ist aus Gründen der Übersichtlichkeit weggelassen. Die nächste Stufe entfernt das zuerst #. Dann verwende ich eine Transliteration (T) -Stufe #T`²-¹`_o`[^¹], um einige der replaceim vollständigen Programm A beschriebenen Vorgänge rückgängig zu machen . Mit dieser Stufe kann eine wörtliche Pilgerfahrt ¶auf der Netzhaut ausgegeben werden , die sonst möglicherweise nicht möglich ist. Sie ersetzt ·mit ¶und ³mit ². Das Auftreten von ¹wird gleich bleiben, da sie mit ignoriert werden [^¹].

Programm A:

Zeilenumbrüche und Tabulatoren wurden zur besseren Lesbarkeit hinzugefügt.

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}|^.

Dies folgt der allgemeinen Struktur der folgenden Python-Quine:

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

Wenn Sie Dinge davor oder danach hinzufügen, müssen Sie sie auch in die Zeichenfolge einfügen.

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

Ich wollte eine dreifach zitierte Zeichenfolge verwenden, um das Einfügen von Anführungszeichen zu vereinfachen (ohne Backslashes). s=U(39)*3;ist die Zeichenfolge '''. Ich habe %sstattdessen auch verwendet %r, um Probleme mit Zeilenumbrüchen oder anderen Zeichen zu vermeiden, die mit Backslashes maskiert werden.

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

Also jetzt die Ersetzungen. Die erste Ersetzung .replace(U(9),U(96));dient dazu, Tabulatoren durch die in Programm B angezeigten Backticks zu ersetzen. Diese Ersetzung erfolgt vor der Formatierung der Zeichenfolgen, da die Tabulatoren in Programm A Tabulatoren bleiben müssen. Die anderen Ersetzungen dienen lediglich dazu, die Verwendung bestimmter Zeichen in Programm 2 zu vermeiden Programmlinie 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

Diese letzten drei Ersetzungen nehmen die Transliterationsphase in Programm B vorweg, um zu verhindern, dass diese Zeichen entfernt oder transliteriert werden, wenn dies nicht der Fall sein sollte.

Der einzige andere Teil des Codes ist der Code aus Programm B, der im Wesentlichen zeichenweise kopiert wird, mit Ausnahme der Änderungen aufgrund der Ersetzungen.

¹ Vielen Dank an Martin für seinen Tipp, wie man ein Literal ¶in der Netzhaut ausgibt . Es hat alles so viel einfacher gemacht.

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

Programm A: Versuchen Sie es in Befunge | Versuchen Sie es in 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:]'''

Programm B: Versuchen Sie es in Python | Versuchen Sie es in 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:]'''"""

Programm C: Versuchen Sie es in Befunge | Versuchen Sie es in Python

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

Erläuterung

Programm C: Dies beruht auf der Tatsache, dass Befunge-93 nicht unterstützte Befehle ignoriert. Während also pharmlos eine Null bei 0; 0 geschrieben wird, wird der Rest des Befehls printbis zu dem <Befehl ignoriert, der die Richtung umkehrt . Anschließend wird von rechts nach links +5+5eine 10 (Zeilenvorschub) gefolgt von der Nachrichtenzeichenfolge auf den Stapel geschoben, und anschließend wird eine Standardausgabesequenz ausgeführt, um die Zeichenfolge zu schreiben. In Python werden nur zwei Zeichenfolgenliterale gedruckt, die miteinander verknüpft sind. Die erste Zeichenfolge (die den Befunge-Code enthält) wird jedoch durch die Array-Referenz am Ende ( [+5+5:]) getrennt.

Programm B: Die erste Zeile ist eine ziemlich einfache Befunge-Sequenz zum Ausdrucken von Programm C. Das einzig Interessante ist die Art und Weise, wie Anführungszeichen unter Verwendung von 50g(dh Lesen der Zeichen aus dem Speicher) erzeugt werden, was effizienter ist als die Berechnung des ASCII-Codes. Das #>(eine Brücke über den Befehl direction) ist im Wesentlichen ein NOP, der verhindert, dass der Code von Python gesehen wird, da #es sich um das Python-Kommentarzeichen handelt. Die Python-Interpretation beginnt in Zeile zwei und gibt einfach eine mehrzeilige Zeichenfolge aus, die den Quellcode von Programm A enthält.

Programm A: In Python werden die ersten drei Zeilen wieder ignoriert, da sie mit beginnen #, während die letzte Zeile einfach Programm C ausgibt. Der Befunge-Code wandert zwischen den ersten drei Zeilen hin und her und bildet die Quelle für Programm B auf dem Stapel in umgekehrter Reihenfolge. Es beginnt mit drei Anführungszeichen, dann einer Sequenz, die eine Kopie der Quelle von Programm A erstellt, und schließlich, was im Wesentlichen eine fest codierte Zeichenfolge mit der Öffnung print """und der ersten Zeile des Befunge-Codes ist. Es ist dann nur noch eine Frage des Ausschreibens mit einer Standardausgabesequenz.

Einige Streitpunkte:

1. Mir wurde gesagt, dass eine Quine, die den gBefehl verwendet, für diese Community keine richtige Quine ist. Ich bin mir nicht sicher, ob diese Regel auch für diese Herausforderung gelten würde, aber in diesem Fall wird diese Antwort möglicherweise auch nicht als angemessene Lösung angesehen.

2. Befunge-93 ignoriert zwar nicht unterstützte Anweisungen, dies ist jedoch in der Spezifikation technisch nicht definiert, und Sie müssen die -q(leise) Befehlszeilenoption im Referenzinterpreter verwenden, um Warnungen in Programm C zu vermeiden Es ist zwar in Ordnung, aber einige der schuppigeren könnten möglicherweise abstürzen. Beachten Sie auch, dass Befunge-98 nicht unterstützte Anweisungen berücksichtigt, sodass ein 98-Interpreter nur eine unbegrenzte Schleife ausführt.

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

Ich glaube nicht, dass ich 52 Bytes vom zugrunde liegenden Mechanismus für das Kopfgeld freigeben kann, aber es hat mir Spaß gemacht, dies zu erstellen. Ich denke, was ich produziert habe, erfüllt die Kriterien ...

Programm 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($_)

Programm 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($_)

Programm 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($_)

Erläuterung

Verwendet mein Perl / JavaScript-Polyquin als Basis , legt jedoch eine zusätzliche Variable fest$P die steuert, welches Programm generiert werden soll. Verwendet die Prüfung, die +[]in Perl wahr ist, in JavaScript jedoch falsch.