Tạo chương trình A sao cho chạy chương trình đó bằng ngôn ngữ A tạo Chương trình B và chạy chương trình A bằng ngôn ngữ B tạo chương trình C.

Chương trình B, khi chạy bằng ngôn ngữ B tạo Chương trình A và chạy chương trình B bằng ngôn ngữ A tạo chương trình C.

Chương trình C, khi chạy bằng ngôn ngữ A hoặc ngôn ngữ B , sẽ in "Ngôn ngữ sai!".

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

Câu trả lời của bạn nên sử dụng mẫu này:

Ngôn ngữ A / Ngôn ngữ B, {a byte} + {b byte} = {tổng byte} byte

Chương trình A:

a code

Chương trình B:

b code

Chương trình C:

c code 

Nguồn:

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

Program A:

    a code
Program B:

    b code
Program C:

    c code

• Không có chương trình nào trong số này nên nhận đầu vào.
• Các phiên bản khác nhau của cùng một ngôn ngữ được tính là các ngôn ngữ khác nhau. (mặc dù điều này không được khuyến khích vì nó dẫn đến các giải pháp nhàm chán)
• Ngôn ngữ A và B phải khác biệt.
• Bạn không được đọc mã nguồn của riêng bạn từ một tập tin. Chương trình có thể không trống
• Tiêu chuẩn áp dụng.

Gợi ý

• C ++ và [Python / Bash / các #ngôn ngữ nhận xét khác] là các combo tốt vì bạn có thể xác định các macro mà một ngôn ngữ có thể bỏ qua

Đây là môn đánh gôn , vì vậy tổng số byte nhỏ nhất sẽ tính Chương trình A và B thắng.

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

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

Hãy thử nó trong Befunge-98! , Hãy thử trong> <>!

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

Hãy thử trong> <>! , Hãy thử nó trong Befunge-98!

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

Hãy thử nó trong Befunge-98! Hãy thử trong> <>!

Làm thế nào nó hoạt động:

Dòng thứ hai trong cả hai chương trình là giống hệt nhau và phục vụ cùng một chức năng cho cả hai ngôn ngữ. Khi được nhập trái từ<<<< , nó sẽ in toàn bộ dòng thứ hai. Khi vào bên phải của những người đó, in chương trình C.

Khi dòng đầu tiên chạy sai ngôn ngữ, nó sẽ đi qua phần sản xuất chương trình C. "Mặt khác, nó in dòng trên cùng về phía sau với ở phía trước và vào phần sản xuất dòng thứ hai.

Dòng đầu tiên

"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

Dòng thứ hai:

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

Chương trình 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

Chương trình 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))//'''

Chương trình 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))

Chương trình C:

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

Có lẽ là chơi gôn ...

Giải thích về JavaScript

Chương trình 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))//'''

Chương trình 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))

Chương trình C:

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

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

Giải thích về Python

Chương trình 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))//'''

Chương trình 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))

Chương trình C:

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

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

Python 3 + JavaScript (Tê giác), 171 + 171 = 342 byte

Chương trình A (đầu ra chương trình B trong Python 3, chương trình C bằng JavaScript; ghi chú dòng mới):

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

Chương trình B (đầu ra chương trình A bằng JavaScript, chương trình C bằng Python; ghi chú dòng mới):

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

Chương trình C (xuất ra "Ngôn ngữ sai!" Bằng một trong hai ngôn ngữ; cũng có một dòng mới, không được tính vào điểm số):

print("Wrong language!")

Lưu ý rằng tôi đang sử dụng một phương ngữ bất thường của JavaScript ở đây. Mọi người thường sử dụng các cài đặt trình duyệt, nhưng những người có vấn đề với đầu ra, thực hiện nó theo một cách kỳ lạ (sử dụng alert). Tôi đang sử dụng gói Ubuntu rhinolà một triển khai JavaScript "ngoại tuyến" với một bộ thư viện khác được triển khai cho một trình duyệt thông thường (dự định là ngôn ngữ kịch bản có thể nhúng); điều đáng chú ý ở chỗ nó cung cấp một printcâu lệnh theo cùng kiểu, ví dụ như Python 3.

Đây là một "polyglot thực sự" theo nghĩa là cả hai ngôn ngữ đang chạy cùng một phép tính, theo cùng một thứ tự, mang lại cho chúng cùng một nghĩa. Cả hai đều có cùng AST (và khá đơn giản để tạo ra một quine polyglot Python 3 + JavaScript thông qua việc giảm chương trình này). Không có mã nào dành riêng cho một ngôn ngữ, điều này giúp tôi giảm độ dài. Ngẫu nhiên, bạn phải sử dụng Python 3 để bạn có thể sử dụng dấu chấm phẩy để phân tách các câu lệnh (nếu bạn đã sử dụng dòng mới, bạn phải thoát khỏi dòng mới).

Chương trình bắt đầu bằng cách xác định các chuỗi svà dgiữ một trích dẫn và trích dẫn kép tương ứng. Điều này cho phép xuất ra các trích dẫn mà không cần phải đề cập đến chúng sau này trong mã nguồn, tránh các vấn đề với việc thoát (điều này dường như thường là vấn đề với các câu hỏi; .

Trung tâm của chương trình là mảng rchứa phần chính của hai chương trình được sử dụng bởi thử thách; một trong những chương trình (chương trình xuất hiện đầu tiên trong chương trình A và thứ hai trong chương trình B) là một chương trình gần như đơn giản chỉ xuất ra chương trình gốc thông qua việc ghép các phần lại với nhau (chủ yếu là từ rchính nó, với một vài chuỗi ký tự) và các chương trình in khác C. Để làm cho chương trình không phải là một câu hỏi thực sự (điều này sẽ khiến chúng tôi không thể phát hiện ra rằng chúng tôi đang chạy sai ngôn ngữ), các yếu tố rđược in theo thứ tự ngược lại; r[0]trong chương trình A nằm r[1]trong chương trình B và ngược lại.

Cuối cùng, tất cả những gì cần thiết là evaluate yếu tố chính xác của r. Điều này được thực hiện bằng cách sử dụng biểu thức ([11]+[0])[1]tạo ra một giá trị khác trong Python 3 và trong JavaScript. Cả hai ngôn ngữ đều phân tích nó một cách giống hệt nhau, nhưng chúng có những ý tưởng khác nhau về việc bổ sung vào danh sách:

• Khi Python 3 thêm [11]vào [0], nó nhận được [11, 0](nối các danh sách), và sau đó lấy phần tử thứ hai của danh sách ( [1]) cung cấp cho chúng ta số nguyên 0.

• Khi JavaScript thêm [11]vào [0], nó nhận được "110"(nối các biểu diễn chuỗi của danh sách) và sau đó lấy ký tự thứ hai của chuỗi ( [1]) cung cấp cho chúng ta chuỗi "1", JavaScript rất vui khi sử dụng làm chỉ mục vào danh sách.

Do đó, Python 3 chạy phần tử đầu tiên rtrong cả hai chương trình (tạo ra phần lớn khi chạy chương trình A và in chương trình C khi chạy chương trình B); JavaScript chạy phần tử thứ hai và do đó xử lý chương trình A và chương trình B theo cách ngược lại.

Ngẫu nhiên, nếu bạn chạy chương trình A trong Ruby, nó sẽ in chương trình B trừ khi không có dòng mới. Nếu bạn chạy chương trình B trong Ruby, nó sẽ in chương trình C trừ khi không có dòng mới. Nói cách khác, giải pháp này gần như hoạt động với một nhóm ngôn ngữ khác, hoán đổi Python 3 cho Ruby (lý do duy nhất tôi không xóa dòng mới khỏi chương trình B để có điểm 341 là sự không nhất quán dòng mới trong chương trình C sẽ không đủ điều kiện nộp bài).

(Tôi đã làm việc trên một "polyglot thực sự" như thế này vì một lý do khác, mà bây giờ tôi đã đăng lên như một thách thức, và nhận ra rằng các kỹ thuật cũng có thể được điều chỉnh theo cách này.)

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

Chương trình 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))

Chương trình 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))

Chương trình C:

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

Tôi đã sử dụng gợi ý của bạn về việc sử dụng C / C ++ với Python. Không ngắn gọn lắm, nhưng tôi vẫn đủ điều kiện.

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

Tôi không chắc chắn nếu unichrvà replacecác bộ phận có thể được chơi gôn nhiều hơn. Tôi đã thử sử dụng Python 3, nhưng rất nhiều mất mát khi phải thêm dấu ngoặc đơn và xử lý chúng. Tôi đã thử cài đặt R=unicode.replacevà sử dụng nó, nhưng đầu ra bị rối.

Lưu ý rằng Retina có một dòng mới ở đầu ra theo mặc định và điều này không được bao gồm trong các chương trình. Nếu ai đó nói tôi cần loại bỏ nó, điều đó có thể được thực hiện một cách tầm thường. Ngoài ra, mã Python hoạt động trong repl.it, nhưng không được bảo đảm để hoạt động trên Ideone.com.

Cũng lưu ý rằng các dòng mới hàng đầu và theo dõi có ý nghĩa trong mã dưới đây.

Chương trình A (Python 2): 638 587 566 550 byte (UTF-8)

Python 2 , võng mạc

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

Chương trình B (Retina): 735 667 655 645 byte (ISO 8859-1)

Võng mạc , 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

Chương trình C:

Python 2 , võng mạc

Điều này thực sự có thể được thực hiện ngắn hơn bằng cách sử dụng #!`W.*!thay vì hai dòng cuối cùng, nhưng điều này làm cho A và B dài hơn, bởi vì `trong một dòng không có nghĩa là tôi cần phải xử lý nó khác nhau (vì backtick đầu tiên trong một dòng trong Retina là một dấu phân cách cấu hình).

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

Giải trình:

Chương trình 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

Tôi đã viết Chương trình C đầu tiên trong lần thử đầu tiên của tôi và giữ nó gần như giống nhau. Trong Python, nó in chuỗi và bỏ qua nhận xét. Trong Retina, nó thay thế không có gì print"Wrong language!"và sau đó loại bỏ các phần xung quanh Wrong language!.

Để hiểu rõ hơn về các chương trình phức tạp, hãy xem các phiên bản đơn giản hóa:

Chương trình A (đơn giản hó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}|^.

Khi tôi bắt đầu lại từ đầu, tôi đã sử dụng PYTHONbit làm trình giữ chỗ cho mã nên in Chương trình A. Phiên bản đơn giản này giúp dễ dàng giải thích cách in cả Chương trình B và Chương trình C.

Và printmọi thứ bên trong là những gì in Chương trình B, nhưng trước tiên, hãy xem Chương trình C được in như thế nào, vì điều đó đơn giản. Sau khi print"..."là #|. Thủ thuật này đã tiết kiệm LOADS về khó khăn mà tôi gặp phải trong lần thử đầu tiên. Điều này cho phép Retina thay thế không có gì bằng dòng thứ 2, sẽ là Chương trình C, ngoại trừ có một #ở phía trước. 2 dòng cuối cùng loại bỏ đầu tiên #. Tôi đã sử dụng #{2}để ngăn chặn các giai đoạn loại bỏ tất cả các lần xuất hiện #. Tôi không thể sử dụng #1`#như tôi đã sử dụng trong Chương trình B, vì nó gây ra sự cố khi có backtick trong dòng đầu tiên của Chương trình A.

Điều này đưa tôi đến nhiệm vụ tiếp theo, in Chương trình B. Bạn có thể nhận thấy một sự khác biệt khác so với mã thực tế. Không có backticks trong mã thực tế, vì tôi đã thay thế chúng bằng các tab. Tôi đã phải thay thế một ký tự, bởi vì bất kỳ backtick nào cũng sẽ biến mã trước đó thành chuỗi cấu hình trong Retina, khiến cú pháp không hợp lệ. Tôi đã chọn các tab vì chúng hiển thị và điểm mã là một chữ số ( 9). Mã in Chương trình B như trong phiên bản đơn giản dưới đây.

Chương trình B:

#PYTHON
#1`#

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

Hai dòng đầu tiên sẽ không thay thế gì bằng mã Python, nhưng #ở phía trước và một số ký tự hơi khác nhau. Phần này được bỏ qua cho rõ ràng. Giai đoạn tiếp theo loại bỏ điều đó đầu tiên #. Sau đó, tôi sử dụng một giai đoạn ngữ (T) #T`²-¹`_o`[^¹]để hoàn tác một số các replacehoạt động nhìn thấy trong A. Chương trình hoàn chỉnh Sử dụng giai đoạn này là một cách để ra một pilcrow đen ¶trong Retina, mà nếu không có thể impossible.¹ Nó thay thế ·với ¶, và ³với ². Sự xuất hiện của ¹sẽ giữ nguyên do chúng bị bỏ qua [^¹].

Chương trình A:

Dòng mới và tab đã được thêm vào để dễ đọc.

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

Điều này tuân theo cấu trúc chung của quine Python sau:

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

Khi bạn thêm những thứ trước hoặc sau, bạn cũng phải đặt chúng vào chuỗi.

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

Tôi muốn sử dụng một chuỗi ba trích dẫn để dễ dàng bao gồm các dấu ngoặc kép (tránh sử dụng dấu gạch chéo ngược). s=U(39)*3;là chuỗi '''. Tôi cũng đã sử dụng %sthay vì %r, để tránh một số vấn đề với dòng mới hoặc các ký tự khác được thoát bằng dấu gạch chéo ngược.

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

Vì vậy, bây giờ, thay thế. Sự thay thế đầu tiên .replace(U(9),U(96));là có để thay thế các tab bằng các backticks mà chúng ta thấy trong Chương trình B. Việc thay thế này được thực hiện trước khi định dạng chuỗi, bởi vì các tab cần duy trì các tab trong Chương trình A. Các thay thế khác chỉ đơn giản là để tránh sử dụng một số ký tự trong phần 2 dòng của Chương trình 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

Ba thay thế cuối cùng này dự đoán giai đoạn Chuyển ngữ trong Chương trình B, để ngăn các ký tự đó bị xóa hoặc phiên âm khi không nên sử dụng.

Phần khác của mã là mã từ Chương trình B về cơ bản được sao chép từng ký tự, ngoại trừ các thay đổi do thay thế.

¹ Nhờ Martin cho mũi của mình về cách ra một chữ ¶trong Retina. Nó làm cho mọi thứ dễ dàng hơn nhiều.

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

Chương trình A: Thử trong Befunge | Thử trong 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:]'''

Chương trình B: Thử trong Python | Thử trong 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:]'''"""

Chương trình C: Thử trong Befunge | Thử trong Python

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

Giải trình

Chương trình C: Điều này phụ thuộc vào thực tế là Befunge-93 bỏ qua các hướng dẫn không được hỗ trợ, do đó, trong khi pvô hại viết số 0 ở 0; 0, phần còn lại printđược bỏ qua cho đến khi <hướng dẫn đảo ngược hướng. Sau đó chảy từ phải sang trái, +5+5đẩy 10 (linefeed) vào ngăn xếp theo chuỗi thông báo và sau đó một chuỗi đầu ra tiêu chuẩn được thực thi để viết ra chuỗi. Trong Python, nó chỉ in hai chuỗi ký tự được nối với nhau, nhưng chuỗi đầu tiên (chứa mã Befunge) bị cắt bởi tham chiếu mảng ở cuối ( [+5+5:]).

Chương trình B: Dòng đầu tiên là một chuỗi Befunge khá cơ bản để in ra Chương trình C. Điều thú vị duy nhất là cách nó tạo ra các ký tự trích dẫn bằng cách sử dụng 50g(tức là đọc ký tự từ bộ nhớ) hiệu quả hơn so với tính toán mã ASCII. Các #>(một cây cầu bắc qua hướng dẫn hướng) về bản chất là một nop có thể ngăn chặn các mã đang được nhìn thấy bởi Python kể từ khi #là những nhận xét nhân vật Python. Việc giải thích Python bắt đầu trên dòng hai và chỉ đơn giản là in một chuỗi nhiều dòng chứa mã nguồn của Chương trình A.

Chương trình A: Trong Python, ba dòng đầu tiên lại bị bỏ qua vì chúng bắt đầu bằng #, trong khi dòng cuối cùng chỉ in ra Chương trình C. Mã Befunge bắt đầu qua lại ba dòng đầu tiên, xây dựng nguồn cho Chương trình B trên ngăn xếp theo thứ tự ngược lại. Nó bắt đầu bằng ba dấu ngoặc kép, sau đó là một chuỗi tạo một bản sao của nguồn Chương trình A và cuối cùng là chuỗi mã hóa cứng với phần mở đầu print """và dòng mã Befunge đầu tiên. Sau đó, vấn đề chỉ là viết nó ra với một chuỗi đầu ra tiêu chuẩn.

Một số điểm tranh cãi:

1. Tôi đã được thông báo rằng một quine sử dụng glệnh không được coi là một quine thích hợp theo như cộng đồng này có liên quan. Tôi không chắc liệu quy tắc đó có áp dụng cho thử thách này không, nhưng nếu vậy, câu trả lời này cũng có thể không được coi là một giải pháp thích hợp.

2. Mặc dù tôi đã nói rằng Befunge-93 bỏ qua các hướng dẫn không được hỗ trợ, nhưng điều đó không được xác định về mặt kỹ thuật trong đặc tả và bạn sẽ cần sử dụng -qtùy chọn dòng lệnh (im lặng) trong trình thông dịch tham chiếu để tránh cảnh báo trong Chương trình C. Hầu hết các trình thông dịch khác sẽ mặc dù tốt, nhưng một số trong những người flakier có thể có khả năng sụp đổ. Cũng lưu ý rằng Befunge-98 phản ánh các hướng dẫn không được hỗ trợ, do đó, trình thông dịch 98 sẽ lặp lại vô thời hạn.

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

Đừng nghĩ rằng tôi có thể chia sẻ 52 byte khỏi cơ chế cơ bản cho tiền thưởng, nhưng tôi rất thích xây dựng nó. Tôi nghĩ những gì tôi đã sản xuất đáp ứng các tiêu chí ...

Chương trình 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($_)

Chương trình 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($_)

Chương trình 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($_)

Giải trình

Sử dụng polyquine Perl / JavaScript của tôi làm cơ sở nhưng đặt một biến bổ sung $Pđể điều khiển chương trình nào sẽ tạo. Sử dụng kiểm tra đó +[]là sự thật trong Perl, nhưng giả mạo trong JavaScript.