언어 A로 실행하면 프로그램 B가 생성되고 언어 B로 프로그램 A를 실행하면 프로그램 C가 생성되도록 프로그램 A를 생성하십시오.

언어 B에서 실행될 때 프로그램 B는 프로그램 A를 생성하고 언어 A에서 프로그램 B를 실행하면 프로그램 C가 생성됩니다.

언어 A 또는 언어 B 로 실행될 때 프로그램 C 는 "잘못된 언어!"를 인쇄합니다.

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 bytes} + {b bytes} = {total bytes} 바이트

프로그램 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 / 기타 주석 언어]는 좋은 조합입니다

이것은 code-golf 이므로 바이트의 가장 작은 합계는 프로그램 A와 B가 이깁니다.

비 펀지-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"

> <>에서 사용해보십시오! , 비 펀지-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

자바 스크립트 (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!')

아마 골프를 할 수있는 ...

자바 스크립트 설명

프로그램 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!')

파이썬 설명

프로그램 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파이썬 3과 같은 스타일로 문장을 제공한다는 점에서 주목할 만합니다 .

이것은 두 언어가 동일한 계산을 동일한 순서로 실행하여 동일한 의미를 부여한다는 의미에서 "진정한 폴리 글롯"입니다. 둘 다 동일한 AST를 가지고 있습니다 (그리고이 프로그램을 줄임으로써 Python 3 + JavaScript 폴리 글롯 quine을 만드는 것은 매우 사소합니다). 한 언어에만 해당되는 코드가 없으므로 길이를 줄일 수 있습니다. 또한 세미콜론을 사용하여 명령문을 분리 할 수 ​​있도록 Python 3을 사용해야합니다 (개행을 사용하는 경우 개행을 이스케이프해야 함).

이 프로그램은 문자열을 정의하여 시작 s하고 d있는 각각 작은 따옴표와 큰 따옴표를 누르고 있습니다. 따라서 소스 코드에서 나중에 언급하지 않고 따옴표를 출력 할 수 있습니다. .

프로그램의 핵심은 r도전에 의해 사용되는 두 프로그램의 본체를 보유 하는 배열 입니다. 프로그램 중 하나 (프로그램 A에서 첫 번째 프로그램 B에서 두 번째로 제공되는 프로그램)는 조각을 연결하여 (대부분의 r문자열 리터럴 로 대부분 자체적 으로 가져옴) 원래 프로그램을 간단히 출력하는 거의 Quine입니다 . 다른 인쇄 프로그램 C. 프로그램을 실제 퀴인 (Quine)으로 만들지 않기 위해 (우리가 잘못된 언어로 실행되고 있음을 감지하는 것을 불가능하게 함), 요소는 r역순으로 인쇄됩니다. r[0]프로그램 A r[1]에서 프로그램 B에 있고 그 반대도 마찬가지입니다.

마지막으로 필요한 것은 eval의 올바른 요소를 사용하는 것입니다 r. 이것은 ([11]+[0])[1]Python 3과 JavaScript에서 다른 값을 생성하는 표현식 을 사용하여 수행됩니다 . 두 언어 모두 똑같이 구문 분석하지만 목록에 추가하는 기능에 대한 아이디어가 다릅니다.

• 파이썬 3 추가 할 때 [11]에 [0], 그것은됩니다 [11, 0](목록을 연결), 다음 (목록의 두 번째 요소를 가지고 [1]우리에게 정수 0을 준다).

• 자바 스크립트를 추가 할 때 [11]에 [0], 그것은 도착 "110"합니다 (합치 의 문자열 표현 목록을), 다음 (문자열의 두 번째 문자를 복용하는 것은 [1]) 우리에게 문자열을 제공 "1"자바 스크립트 목록 인덱스로 사용하는 것이 매우 행복하다.

따라서 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 2 / Retina, 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)

파이썬 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 바이트 (8859-1 ISO)

망막 , 파이썬 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 :

파이썬 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를 먼저 작성했으며 대부분 동일하게 유지했습니다. 파이썬에서는 문자열을 인쇄하고 주석을 무시합니다. 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

처음 두 줄은 파이썬 코드로 대체되지 않지만 #앞과 일부 문자는 약간 다릅니다. 이 부분은 명확성을 위해 생략되었습니다. 다음 단계에서는 먼저 제거합니다 #. 그 후, 나는 음역 (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

이 마지막 3 개의 대체품은 프로그램 B의 음역 단계를 예상하여 이러한 문자가 없어야 할 경우 음역이 제거되거나 음역되는 것을 방지합니다.

코드의 유일한 다른 부분은 대체로 인한 변경을 제외하고 본질적으로 문자별로 복사되는 프로그램 B의 코드입니다.

¹ Retina 에서 리터럴을 출력하는 방법에 대한 팁을 제공 한 Martin에게 감사합니다 ¶. 모든 것이 훨씬 쉬워졌습니다.

비 펀지 / 파이썬, 381 + 485 259 + 345 229 + 304 = 533 바이트

프로그램 A : Befunge 시도 | 파이썬으로 시도

#>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 : 파이썬으로 시도 | 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 시도 | 파이썬으로 시도

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

설명

프로그램 C : 이것은 Befunge-93이 지원되지 않는 명령어를 무시한다는 사실에 의존합니다 . 따라서 p0; 0에 무해하게 0 을 쓰지만 방향을 바꾸는 명령어 print까지 나머지 는 무시됩니다 <. 그런 다음 오른쪽에서 왼쪽으로 흐르면 +5+5스택에 10 (줄 바꿈)을 누른 다음 메시지 문자열이 표시된 다음 표준 출력 시퀀스가 ​​실행되어 문자열을 씁니다. 파이썬에서는 함께 연결된 두 개의 문자열 리터럴을 인쇄하지만 첫 번째 (Befunge 코드 포함)는 끝에 배열 참조에 의해 분리됩니다 ( [+5+5:]).

프로그램 B : 첫 번째 행은 프로그램 C를 인쇄하는 상당히 기본적인 Befunge 시퀀스입니다. 유일한 흥미로운 점은 50gASCII 코드를 계산하는 것보다 효율적인 따옴표 문자 (메모리에서 문자 읽기) 를 생성하는 방법 입니다. #>(방향 지시 위에 다리)는 본질적으로부터 파이썬 볼되고있는 코드 방지하는 NOP입니다 #파이썬 주석 문자입니다. 파이썬 해석은 2 행에서 시작하며 단순히 Program A의 소스 코드를 포함하는 여러 줄 문자열을 인쇄합니다.

프로그램 A : 파이썬에서 처음 세 줄은로 시작하기 때문에 다시 무시 #되고 마지막 줄은 단순히 프로그램 C를 출력합니다. Befunge 코드는 처음 세 줄을 앞뒤로 스 네이 핑하여 스택에 프로그램 B의 소스를 만듭니다. 역순으로. 세 개의 따옴표로 시작하고, 그 다음에 Program A의 소스를 복사하는 시퀀스와 마지막 print """으로 Befunge 코드의 첫 줄과 첫 줄이 있는 하드 코딩 된 문자열이 무엇인지 확인 하십시오. 그런 다음 표준 출력 시퀀스로 작성하면됩니다.

경합의 일부 포인트 :

1. g이 커뮤니티와 관련 하여 명령을 사용하는 quine 은 적절한 quine으로 간주되지 않는다고 들었습니다 . 그 규칙이이 도전에 적용되는지 확실하지 않지만, 그렇다면이 대답도 적절한 해결책으로 간주되지 않을 수 있습니다.

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에서는 잘못된 검사를 사용합니다 .