จัดทำโปรแกรม A ที่ใช้งานในภาษา A สร้างโปรแกรม B และใช้งานโปรแกรม A ในภาษา B สร้างโปรแกรม C

โปรแกรม 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 bytes} + {b 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 / #ภาษาที่ถูกคอมเม้นต์อื่น ๆ] เป็นคอมโบที่ดีเพราะคุณสามารถกำหนดมาโครที่ภาษาหนึ่งสามารถเพิกเฉยได้

นี่คือโค้ดกอล์ฟดังนั้นผลรวมที่เล็กที่สุดของจำนวนไบต์จึงนับว่าโปรแกรม 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!')

คำอธิบายหลาม

โปรแกรม 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 (แสดงผลโปรแกรม B ใน Python 3, โปรแกรม C ใน JavaScript; ขึ้นบรรทัดใหม่ตามหมายเหตุ):

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 (เอาต์พุตโปรแกรม A ใน JavaScript, โปรแกรม C ใน Python; การขึ้นบรรทัดใหม่ของบันทึกย่อ):

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) ฉันใช้แพคเกจ Ubuntu rhinoซึ่งเป็น JavaScript แบบออฟไลน์ที่มีไลบรารี่ชุดอื่นที่นำไปใช้กับเบราว์เซอร์ทั่วไป (เป็นภาษาสคริปต์ที่ฝังตัวได้) สิ่งนี้มีความโดดเด่นในการให้printคำสั่งในรูปแบบเดียวกับเช่น Python 3

นี่คือ "พูดได้หลายภาษาจริง" ในแง่ที่ว่าทั้งสองภาษาใช้การคำนวณเดียวกันในลำดับเดียวกันทำให้พวกเขามีความหมายเดียวกัน พวกเขาทั้งสองมี AST เหมือนกัน (และมันค่อนข้างง่ายที่จะสร้าง Python 3 + JavaScript polyglot Quine ผ่านการลดโปรแกรมนี้) ไม่มีรหัสที่เฉพาะเจาะจงสำหรับหนึ่งภาษาซึ่งช่วยให้ฉันลดความยาวลงได้ อนึ่งคุณต้องใช้ Python 3 เพื่อให้คุณสามารถใช้เครื่องหมายอัฒภาคเพื่อแยกคำสั่ง (ถ้าคุณใช้การขึ้นบรรทัดใหม่ที่คุณต้องหลบเลี่ยงการขึ้นบรรทัดใหม่)

โปรแกรมเริ่มต้นด้วยการกำหนดสตริงsและdที่มีเครื่องหมายคำพูดเดี่ยวและเครื่องหมายคำพูดคู่ตามลำดับ สิ่งนี้ทำให้มันเป็นไปได้ที่จะแสดงผลการเสนอราคาโดยไม่ต้องพูดถึงมันในซอร์สโค้ด, หลีกเลี่ยงปัญหาเกี่ยวกับการหลบหนี (ซึ่งบ่อยครั้งดูเหมือนจะมีปัญหากับ quines; เหตุผลหลักที่ฉันตอบปัญหา quine จำนวนมากใน Underload คือ .

หัวใจของโปรแกรมคืออาร์เรย์rที่มีเนื้อหาหลักของทั้งสองโปรแกรมที่ใช้โดยความท้าทาย หนึ่งในโปรแกรม (โปรแกรมที่มาเป็นอันดับแรกในโปรแกรม A และที่สองในโปรแกรม B) เป็นโปรแกรมที่เกือบจะทำหน้าที่ออกโปรแกรมดั้งเดิมผ่านการต่อข้อมูลเข้าด้วยกันเป็นส่วน ๆ (ส่วนใหญ่มาจากrตัวเองด้วยสตริงตัวอักษรสองสามตัว) และ โปรแกรมการพิมพ์อื่น C. เพื่อทำให้โปรแกรมไม่ใช่ quine จริง (ซึ่งจะทำให้ไม่สามารถตรวจพบว่าเรากำลังทำงานในภาษาที่ไม่ถูกต้อง) องค์ประกอบของการrพิมพ์จะถูกเรียงกลับกัน r[0]ในโปรแกรม A อยู่r[1]ในโปรแกรม B และในทางกลับกัน

ในที่สุดทุกสิ่งที่จำเป็นเพื่อevaluate 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ทั้งสองโปรแกรม (การผลิตเกือบจะเป็น quine เมื่อรันโปรแกรม A และการพิมพ์โปรแกรม C เมื่อรันโปรแกรม B) JavaScript เรียกใช้องค์ประกอบที่สองและถือว่าโปรแกรม 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!")

ฉันใช้คำใบ้ในการใช้ C / C ++ กับ Python ไม่รัดกุมมาก แต่ก็ยังถือว่ามีคุณสมบัติฉันคิดว่า

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

โปรแกรม 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 , Retina

สิ่งนี้สามารถทำให้สั้นลงได้โดยใช้#!`W.*!แทนที่จะเป็นสองบรรทัดสุดท้าย แต่สิ่งนี้ทำให้ A และ B ยาวขึ้นเนื่องจากการมี`สายที่ไม่มีใครหมายความว่าฉันต้องจัดการมันต่างกัน (เพราะ backtick เส้นแรกใน 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 มันจะพิมพ์สตริงและละเว้นความคิดเห็น ในจอประสาทตาจะแทนที่ด้วยอะไรแล้วเอาชิ้นส่วนที่อยู่รอบ ๆ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 ซึ่งจะเป็น Program C ยกเว้นว่ามี#ด้านหน้า สุดท้าย 2 #สายเอาที่แรก ฉันใช้#{2}เพื่อป้องกันไม่ให้เวทีจากลบทั้งหมด#เกิดขึ้นของ ฉันไม่สามารถใช้#1`#เหมือนที่ใช้ในโปรแกรม B เพราะมันทำให้เกิดปัญหากับ backtick นั้นในบรรทัดแรกของโปรแกรม A

ซึ่งนำฉันไปสู่ภารกิจต่อไปของฉันการพิมพ์โปรแกรม B คุณอาจสังเกตเห็นความแตกต่างจากรหัสจริง ไม่มีการตีกลับในรหัสจริงเนื่องจากฉันแทนที่ด้วยแท็บ ฉันต้องแทนที่ตัวละครเพราะ backtick ใด ๆ ที่จะทำให้รหัสก่อนหน้านี้เป็นสตริงการกำหนดค่าใน 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 ที่สมบูรณ์การใช้สเตจนี้เป็นวิธีหนึ่งในการส่ง pilcrow ที่แท้จริง¶ใน Retina ซึ่งอาจเป็นไปไม่ได้¹ แทนที่·ด้วย¶และ³ด้วย². การเกิดขึ้นของจะอยู่เนื่องจากเดียวกันกับพวกเขาถูกละเลยด้วย¹[^¹]

โปรแกรม 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));มีไว้เพื่อแทนที่แท็บด้วย backticks ที่เราเห็นในโปรแกรม B การแทนที่นี้ทำได้ก่อนการจัดรูปแบบสตริงเนื่องจากแท็บจำเป็นต้องคงแท็บในโปรแกรม A การแทนที่อื่น ๆ นั้นเพื่อหลีกเลี่ยงการใช้อักขระบางตัวในตัวที่ 2 สายของโปรแกรม 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 ที่ถูกคัดลอกตัวอักษรต่ออักขระยกเว้นการเปลี่ยนแปลงอันเนื่องมาจากการแทนที่

¹ ขอบคุณมาร์ตินสำหรับเคล็ดลับของเขาเกี่ยวกับวิธีการแสดงผลตัวอักษร¶ใน Retina มันทำให้ทุกอย่างง่ายขึ้นมาก

Befunge / หลาม 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 (linefeed) ไปยังสแต็กตามด้วยสตริงข้อความจากนั้นลำดับเอาต์พุตมาตรฐานจะถูกดำเนินการเพื่อเขียนสตริง ใน Python เพียงแค่พิมพ์ตัวอักษรสตริงสองตัวที่ต่อกันเข้าด้วยกัน แต่ตัวแรก (ที่มีรหัส Befunge) จะถูกตัดออกโดยการอ้างอิงอาร์เรย์ที่ส่วนท้าย ( [+5+5:])

โปรแกรม B:บรรทัดแรกเป็นลำดับของ Befunge ขั้นพื้นฐานที่จะพิมพ์โปรแกรม C สิ่งที่น่าสนใจเพียงอย่างเดียวคือวิธีที่มันสร้างอักขระเครื่องหมายคำพูดโดยใช้50g(เช่นการอ่านอักขระจากหน่วยความจำ) ซึ่งมีประสิทธิภาพมากกว่าการคำนวณรหัส ASCII #>(เป็นสะพานข้ามคำแนะนำและทิศทาง) เป็นหลัก nop ที่ป้องกันไม่ให้รหัสที่ถูกมองเห็นได้ด้วยงูหลามตั้งแต่#เป็นงูหลามตัวอักษรแสดงความคิดเห็น การตีความ 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 polyquineของฉันเป็นพื้นฐานแต่ตั้งค่าตัวแปรเพิ่มเติม$Pซึ่งควบคุมโปรแกรมที่จะสร้าง ใช้การตรวจสอบที่+[]เป็นจริงใน Perl แต่เท็จใน JavaScript