产生一个程序A，以便以语言A运行它会产生程序B，而以语言B运行程序A会产生程序C。

以语言B运行时，程序B生成程序A，以语言A运行程序B时生成程序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 /其他#注释语言]是很好的组合，因为您可以定义一种语言可以忽略的宏

这是代码高尔夫球，因此，程序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中尝试一下！ 在> <>中尝试！

怎么运行的：

两个程序中的第二行相同，并且两种语言的功能相同。从中向左输入时<<<<，它将打印第二行。当输入到它们的右侧时，打印程序C。

当第一行以错误的语言运行时，它将通过程序C产生部分进入。否则，它将顶行向后打印顶行，"并进入第二行生成部分。

第一行

"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（以任何一种语言输出“ Wrong language！”；还带有结尾的换行符，该分数不计入分数）：

print("Wrong language!")

请注意，我在这里使用了不寻常的JavaScript方言。人们通常使用浏览器实现，但是那些输出存在问题，以一种奇怪的方式来实现（使用alert）。我使用的是Ubuntu软件包rhino，它是“离线” JavaScript实现，具有针对典型浏览器实现的一组不同的库（它旨在作为可嵌入的脚本语言）；值得注意的是，它提供了print与Python 3相同的样式的语句。

从两种语言都以相同的顺序运行相同的计算，赋予它们相同的含义的意义上来说，这是“真正的通配符”。它们都具有相同的AST（并且通过简化该程序来创建Python 3 + JavaScript多语言quine是相当琐碎的）。没有特定于一种语言的代码，这可以帮助我缩短长度。顺便说一句，您必须使用Python 3，以便可以使用分号分隔语句（如果使用换行符，则必须转义换行符）。

该方案通过定义字符串开头s，并d分别持有单引号和双引号。这样就可以输出引号，而不必在源代码中稍后提及它们，避免了转义的问题（这似乎经常是quines的问题；我在Underload中回答这么多quine问题的主要原因是它的字符串嵌套了） 。

程序的核心是数组r，其中包含挑战使用的两个程序的主体。其中一个程序（第一个出现在程序A中，第二个出现在程序B中）是一个几乎是quine的程序，它通过将片段连接在一起（主要是从r自身中获取，带有一些字符串文字）来简单地输出原始程序，并且其他打印程序C.为了使该程序不是真正的工具（不可能检测到我们在错误的语言中运行），r以相反的顺序打印；r[0]程序A r[1]中的程序位于程序B中，反之亦然。

最后，所需eval要做的就是使用的正确元素r。这是通过使用([11]+[0])[1]在Python 3和JavaScript中产生不同值的表达式来实现的。两种语言都以相同的方式解析它，但是对于列表的附加功能他们有不同的想法：

• 当Python 3添加[11]到时[0]，它得到[11, 0]（连接列表），然后取列表的第二个元素（[1]）给我们整数0。

• 当JavaScript添加[11]到时[0]，它会获取"110"（连接列表的字符串表示形式），然后采用字符串（[1]）的第二个字符为我们提供字符串"1"，JavaScript非常乐意将其用作列表的索引。

因此，Python 3 r在两个程序中都运行第一个元素（运行程序A时生成几乎一字形，运行程序B时生成程序C）；JavaScript运行第二个元素，因此以相反的方式对待程序A和程序B。

顺便说一句，如果您在Ruby中运行程序A，它将打印程序B，除非没有尾随换行符。如果您在Ruby中运行程序B，它将打印程序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!")

我使用了将C / C ++与Python结合使用的提示。不是很简洁，但我想还是可以排位赛。

Python 2 /视网膜，550 + 645 = 1373 1254 1221 1195字节

我不太确定unichr和replace零件是否可以打更多的高尔夫球。我尝试使用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（视网膜）：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.*!代替最后两行来使其更短，但这会使A和B更长，因为`在没有行的行中意味着我需要以不同的方式处理它（因为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可以用第二行替换任何内容，第二行将是程序C，除了#前面有一个。最后两行首先删除该行#。我曾经#{2}防止该阶段删除所有出现的#。我不能#1`#像在程序B中那样使用它，因为它会导致问题在程序A的第一行中出现反勾号。

这将我带入下一个任务，即打印程序B。您可能已经注意到与实际代码的另一个区别。实际的代码中没有反引号，因为我用制表符代替了它们。我必须替换一个字符，因为任何反引号都会使早期代码成为Retina中的配置字符串，从而导致语法无效。我选择选项卡是因为它们是可见的，并且代码点是一位数字（9）。该代码将打印程序B，如下面的简化版本所示。

程式B：

#PYTHON
#1`#

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

前两行将不会用Python代码替换任何内容，而是#在前面加上一个字符，并且某些字符略有不同。为了清楚起见，省略了该部分。下一阶段首先将其删除#。然后，我用的音译（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 quine的一般结构：

_='_=%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

这最后三个替换项将在程序B中实现音译阶段，以防止在不应该删除或删除这些字符时将其删除或音译。

该代码的唯一其他部分是来自程序B的代码，该代码本质上是逐字符复制的，但由于替换引起的更改除外。

¹ 感谢Martin提供的有关如何¶在Retina中输出文字的技巧。它使一切变得如此容易。

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中，它只是打印两个串联在一起的字符串文字，但是第一个（包含Befunge代码）被数组引用的末尾（[+5+5:]）分割。

程序B：第一行是打印程序C的相当基本的Befunge序列。唯一有趣的是，它使用50g（即从内存中读取字符）生成引号字符的方式比计算ASCII代码更有效。的#>（在方向指示的桥）基本上防止被Python被看到由于码的NOP #是Python注释字符。Python的解释从第二行开始，仅打印包含程序A源代码的多行字符串。

程序A：在Python中，前三行再次被忽略，因为它们以开头#，而最后一行仅打印出程序C。Befunge代码在前三行中来回蛇行，从而在堆栈上建立了程序B的源代码以相反的顺序。它以三个引号开头，然后是复制程序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聚喹啉作为基础，但设置一个附加变量$P来控制要生成的程序。使用+[]在Perl中正确但在JavaScript中错误的检查。