言語Aで実行するとプログラムBが生成され、言語BでプログラムAを実行するとプログラムCが生成されるように、プログラムAを生成します。

プログラムB、言語Bで実行するとプログラムAが生成され、プログラムBを言語Aで実行するとプログラムCが生成されます。

プログラムCを言語Aまたは言語Bで実行すると、「間違った言語！」が出力されます。

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

答えは次のテンプレートを使用する必要があります。

言語A /言語B、{aバイト} + {bバイト} = {合計バイト}バイト

プログラムA：

a code

プログラムB：

b code

プログラムC：

c code 

ソース：

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

Program A:

    a code
Program B:

    b code
Program C:

    c code

• これらのプログラムはどれも入力を受け付けません。
• 同じ言語の異なるバージョンは、異なる言語としてカウントされます。（これは退屈な解決策につながるため、推奨されません）
• 言語AとBは区別する必要があります。
• ファイルから独自のソースコードを読み取ってはなりません。プログラムは空ではないかもしれません
• 標準の抜け穴が適用されます。

ヒント

• C ++と[Python / Bash /他の#コメント言語]は、1つの言語で無視できるマクロを定義できるため、優れたコンボです。

これはcode-golfであるため、バイトカウントの最小合計がプログラムAとプログラムBに勝ちます。

Befunge-98（PyFunge） / > <>、123 + 123 = 266 250 246バイト

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

Befunge-98で試してください！、> <>で 試してみてください！

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

> <>で試してみてください！、Befunge-98で 試してみてください！

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

Befunge-98で試してください！ > <>で試してみてください！

使い方：

両方のプログラムの2行目は同一であり、両方の言語で同じ機能を果たします。から左に入力<<<<すると、2行目全体が印刷されます。それらの右側に入るとき、プログラムCを印刷します。

最初の行が間違った言語で実行されると、プログラムC作成セクションから入ります。それ以外の場合は、先頭行を先頭に後方に印刷し"、2番目の行生成セクションに入ります。

最初の行

"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

二行目：

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

プログラム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バイト

プログラム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))//'''

プログラム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))

プログラムC：

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

おそらくゴルフ可能...

JavaScriptの説明

プログラム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))//'''

プログラム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))

プログラムC：

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

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

Pythonの説明

プログラム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))//'''

プログラム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))

プログラム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バイト

プログラムA（Python 3でプログラムBを出力、JavaScriptでプログラムCを出力、末尾の改行に注意）：

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

プログラムB（JavaScriptでプログラムAを出力、PythonでプログラムCを出力、末尾の改行に注意）：

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

プログラムC（どちらかの言語で「間違った言語！」を出力します。また、スコアにはカウントされない末尾の改行があります）：

print("Wrong language!")

ここでは、JavaScriptの珍しい方言を使用していることに注意してください。人々は通常ブラウザの実装を使用しますが、出力に問題があり、奇妙な方法で（を使用してalert）出力します。私rhinoは、「オフライン」JavaScript実装であるUbuntuパッケージを使用しています。これは、典型的なブラウザーに組み込まれた異なるライブラリーセットを備えています（組み込み可能なスクリプト言語を目的としています）。これはprint、たとえばPython 3と同じスタイルのステートメントを提供するという点で注目に値します。

これは、両方の言語が同じ計算を同じ順序で実行し、それらに同じ意味を与えるという意味での「真の多言語」です。どちらも同じASTを持っています（このプログラムを減らすことでPython 3 + JavaScriptポリグロットキインを作成するのはかなり簡単です）。1つの言語に固有のコードはないため、長さを短縮できます。ちなみに、セミコロンを使用してステートメントを分離するには、Python 3を使用する必要があります（改行を使用した場合は、改行をエスケープする必要があります）。

プログラムは、文字列sを定義することから始まり、dそれぞれ単一引用符と二重引用符を保持します。これにより、ソースコードで後で言及することなく引用符を出力することが可能になり、エスケープの問題を回避できます（これはしばしばクインの問題と思われます。 。

プログラムの中心はr、チャレンジで使用される2つのプログラムの本体を保持する配列です。プログラムの1つ（プログラムAで最初に、プログラムBで2番目に来るもの）は、断片を連結して（ほとんどはrそれ自体から取得し、いくつかの文字列リテラルを使用して）元のプログラムを出力するほぼ同じです。otherはプログラムCを印刷します。プログラムを真の馬ではないようにするため（間違った言語で実行されていることを検出できないようにするため）、の要素はr逆の順序で印刷されます。r[0]プログラムAがr[1]プログラムBにあり、逆も同様です。

最後に、必要なのはeval、の正しい要素を使用することだけrです。これは([11]+[0])[1]、Python 3とJavaScriptで異なる値を生成する式を使用して実現されます。両方の言語は同じように解析しますが、リストに追加することについて異なる考えを持っています。

• Python 3がに追加[11]さ[0]れると[11, 0]（リストを連結して）取得し、リストの2番目の要素（[1]）を取得すると整数0が得られます。

• JavaScriptがに追加[11]さ[0]れると"110"（リストの文字列表現を連結して）取得し、文字列の2番目の文字（[1]）を取得して文字列を取得します"1"。これはJavaScriptがリストのインデックスとして非常に便利です。

そのため、Python 3 rは両方のプログラムの最初の要素を実行します（プログラムAを実行するとほぼ同じ、プログラムBを実行するとプログラムCを印刷します）。JavaScriptは2番目の要素を実行するため、プログラムAとプログラムBを逆に扱います。

ちなみに、プログラムAをRubyで実行すると、末尾の改行がない場合を除き、プログラムBが印刷されます。プログラムBをRubyで実行すると、末尾の改行を除いてプログラムCが印刷されます。言い換えれば、このソリューションは異なる言語のセットでほとんど動作し、Python 3をRubyに交換します（プログラムBから改行を削除して341のスコアを取得する唯一の理由は、プログラムCの改行の不整合です提出を失格させます）。

（私はさまざまな理由でこのような「本当のポリグロット」に取り組んでいましたが、今はチャレンジとして投稿しましたが、この手法もこの手法に適応できることに気付きました。）

C / Python、733バイト+ 733バイト= 1466バイト

プログラム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))

プログラム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))

プログラムC：

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

PythonでC / C ++を使用するというヒントを使用しました。あまり簡潔ではありませんが、まだ資格があると思います。

Python 2 / Retina、550 + 645 = 1373 1254 1221 1195バイト

私があればかなりわからないunichrとreplace部品がよりgolfedすることができます。Python 3を使用してみましたが、括弧を追加して処理する必要があるため、多くのことが失われます。私はそれを設定R=unicode.replaceして使用しようとしましたが、出力が台無しになります。

Retinaの出力にはデフォルトで末尾の改行があり、これはプログラムに含まれていないことに注意してください。削除する必要があると誰かが言った場合、それは簡単に行えます。また、Pythonコードはrepl.itで動作しますが、Ideone.comで動作することは保証されていません。

また、以下のコードでは先頭と末尾の改行が重要であることに注意してください。

プログラムA（Python 2）：638 587 566 550バイト（UTF-8）

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

プログラムB（Retina）：735 667 655 645バイト（ISO 8859-1）

網膜、 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

プログラムC：

Python 2、網膜

実際#!`W.*!には、最後の2行の代わりにこれを使用して短くすることができますが、AとBが長くなります。1つの行`がないと、別の方法で処理する必要があるためです（Retinaの行の最初のバックティック構成の区切り文字です）。

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

説明：

プログラム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

私は最初の試みの際に最初にプログラムCを作成し、ほとんど同じように保ちました。Pythonでは、文字列を出力し、コメントを無視します。Retinaでは、何も置き換えずにprint"Wrong language!"、周囲の部品を削除しますWrong language!。

複雑なプログラムをよりよく理解するために、単純化されたバージョンを見てみましょう。

プログラムA（簡略化）：

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

最初からやり直したときは、 PYTHONプログラムAを印刷するコードのプレースホルダーとしてビット。この単純なバージョンにより、プログラムBとプログラムCの両方の印刷方法を簡単に説明できました。

printそして、すべての内部には、プログラムBを出力するものであるが、まず、それは簡単ですので、プログラムCが印刷されたかを確認することができます。後print"..."です#|。このトリックは、私が最初の試みで経験した困難の負荷を節約しました。これにより、Retinaは2行目で何も置き換えることができません。2行目はプログラムCになりますが#、前にある場合を除きます。最後の2行は最初の行を削除し#ます。以前#{2}は、ステージがすべての出現を削除しないようにしました#。#1`#プログラムAの最初の行にバックティックがあると問題が発生するため、プログラムBで使用したようには使用できません。

次のタスクであるプログラムBを印刷します。実際のコードとは別の違いに気付いたかもしれません。実際のコードには、タブに置き換えたため、バックティックはありません。バックティックがあると以前のコードがRetinaの構成文字列になり、構文が無効になるため、文字を置き換える必要がありました。タブが表示され、コードポイントが1桁（9）であるため、タブを選択しました。コードは、以下の簡略バージョンに示すようにプログラムBを印刷します。

プログラムB：

#PYTHON
#1`#

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

最初の2行はPythonコードで何も置き換えられませんが、#前にa があり、一部の文字が若干異なります。わかりやすくするために、この部分は省略されています。次の段階では、最初にそれを削除し#ます。その後、私は変換（T）のステージを使用する#T`²-¹`_o`[^¹]一部の元に戻すにはreplace、この段階を使用した完全なプログラムAに見操作することはリテラル段落記号を出力する方法です¶それ以外の場合は、置き換えimpossible.¹かもしれない網膜で、·と¶、と³と²。の発生は¹で無視されるため同じまま[^¹]です。

プログラムA：

読みやすくするために、改行とタブが追加されました。

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

これは、次のPythonクインの一般的な構造に従います。

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

前後に物を追加するときは、それらも文字列に入れる必要があります。

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

引用符を含めやすくするために、三重引用符で囲まれた文字列を使用したかった（バックスラッシュの使用を回避）。s=U(39)*3;は文字列'''です。また、改行や他の文字がバックスラッシュでエスケープされるという問題を避けるために、の%s代わりに使用しました%r。

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

だから今、交換。最初の置換.replace(U(9),U(96));は、タブをプログラムBにあるバックティックに置き換えるためのものです。この置換は、プログラムAでタブを保持する必要があるため、文字列の書式設定の前に行われます。プログラム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

これらの最後の3つの置換は、プログラムBの文字変換段階を想定しており、これらの文字が削除されるべきではないときに文字が削除または文字変換されることを防ぎます。

コードのその他の部分は、置換による変更を除き、本質的に文字ごとにコピーされるプログラムBのコードのみです。

¹Retinaでリテラルを出力する方法に関するヒントを提供してくれたMartinに感謝し¶ます。すべてがとても簡単になりました。

Befunge / Python、 381 + 485 259 + 345 229 + 304 = 533バイト

プログラムA： Befungeで試す | 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:]'''

プログラムB： Pythonで試す | 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:]'''"""

プログラムC： Befungeで試す | Pythonで試す

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

説明

プログラムC：これは、Befunge-93がサポートされていない命令を無視するという事実に依存しているためp、0; 0で無害にゼロを書き込んでいる間、残りを方向を反転する命令printまで無視し<ます。次に、右から左へ流れ+5+5て、スタックに10（改行）をプッシュし、その後にメッセージ文字列を続けてから、標準出力シーケンスを実行して文字列を書き出します。Pythonでは、連結された2つの文字列リテラルを出力するだけですが、最初の文字列（Befungeコードを含む）は、末尾（[+5+5:]）の配列参照によって切り取られます。

プログラムB：最初の行は、プログラムCを印刷するためのかなり基本的なBefungeシーケンスです。唯一興味深いのは50g、ASCIIコードを計算するよりも効率的な引用文字を生成する方法です（メモリから文字を読み取る）。#>（方向指示橋）は、本質的にのでPythonが見られるコード防止NOPである#Pythonのコメント文字です。Pythonの解釈は2行目から始まり、プログラムAのソースコードを含む複数行の文字列を出力するだけです。

プログラムA： Pythonでは、最初の3行はで始まるため再び無視されますが#、最後の行は単にプログラムCを出力します。Befungeコードは最初の3行を行き来し、スタック上のプログラムBのソースを構築します。逆の順序で。3つの引用符で始まり、次にプログラムAのソースのコピーを作成するシーケンス、最後print """にBefungeコードの最初と最初の行を含む基本的にハードコードされた文字列です。その場合は、標準出力シーケンスで書き出すだけです。

競合のいくつかのポイント：

1. gこのコミュニティに関する限り、コマンドを使用するクインは適切なクインとは見なされないと言われました。そのルールがこの課題にも当てはまるかどうかはわかりませんが、当てはまる場合、この答えも適切な解決策とはみなされないかもしれません。

2. Befunge-93はサポートされていない命令を無視すると言いましたが、技術的には仕様で定義されていない-qため、プログラムCでの警告を避けるために参照インタープリターで（静かな）コマンドラインオプションを使用する必要があります。他のほとんどのインタープリターはただし、大丈夫ですが、いくつかのより軽薄なものは潜在的にクラッシュする可能性があります。また、Befunge-98はサポートされていない命令を反映するため、98インタプリタは無限にループすることに注意してください。

Perl / JavaScript、176バイト+ 176バイト= 352バイト

バウンティの基本メカニズムから52バイト分を共有できるとは思わないが、これを構築するのは楽しかった。私が制作したものは基準を満たしていると思います...

プログラム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($_)

プログラム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($_)

プログラム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($_)

説明

用途私の基礎としてのPerl / JavaScriptのpolyquineが、追加の変数セット$Pを生成するためのプログラムを制御します。+[]Perlでは真実ですが、JavaScriptでは偽であるチェックを使用します。