Menghasilkan program A sedemikian rupa sehingga menjalankannya dalam bahasa A menghasilkan Program B, dan menjalankan program A dalam bahasa B menghasilkan program C.

Program B, ketika dijalankan dalam bahasa B menghasilkan Program A, dan menjalankan program B dalam bahasa A menghasilkan program C.

Program C, ketika dijalankan dalam bahasa A atau bahasa B , mencetak "Bahasa salah!".

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

Jawaban Anda harus menggunakan templat ini:

Bahasa A / Bahasa B, {a byte} + {b byte} = {total byte} byte

Program A:

a code

Program B:

b code

Program C:

c code 

Sumber:

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

Program A:

    a code
Program B:

    b code
Program C:

    c code

• Tak satu pun dari program ini yang harus menerima input.
• Versi berbeda dari bahasa yang sama dihitung sebagai bahasa yang berbeda. (Meskipun ini tidak disarankan karena mengarah ke solusi yang membosankan)
• Bahasa A dan B harus berbeda.
• Anda tidak boleh membaca kode sumber Anda sendiri dari file. Program mungkin tidak kosong
• Celah standar berlaku.

Petunjuk

• C ++ dan [Python / Bash / #bahasa lain yang dikomentari] adalah kombinasi yang baik karena Anda dapat mendefinisikan makro yang diabaikan oleh satu bahasa

Ini adalah kode-golf , sehingga jumlah terkecil dari byte menghitung Program A dan B yang menang.

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"

Cobalah di Befunge-98! , Coba di> <>!

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

Coba di> <>! , Cobalah di Befunge-98!

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

Cobalah di Befunge-98! Coba di> <>!

Bagaimana itu bekerja:

Baris kedua di kedua program identik dan melayani fungsi yang sama untuk kedua bahasa. Ketika dimasukkan ke kiri dari <<<<, itu akan mencetak seluruh baris kedua. Saat memasuki sebelah kanan itu, cetak program C.

Ketika baris pertama dijalankan dalam bahasa yang salah, itu masuk melalui bagian produksi program C. Kalau tidak, ia akan mencetak garis paling atas ke belakang dengan "di bagian depan dan memasuki bagian penghasil baris kedua.

Garis pertama

"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

Baris kedua:

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

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 byte

Program 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))//'''

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

Program C:

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

Mungkin golf ...

Penjelasan JavaScript

Program 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))//'''

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

Program C:

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

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

Penjelasan python

Program 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))//'''

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

Program C:

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

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

Python 3 + JavaScript (Badak), 171 + 171 = 342 byte

Program A (output program B dalam Python 3, program C dalam JavaScript; note trailing newline):

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

Program B (output program A dalam JavaScript, program C dengan Python; note trailing newline):

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

Program C (menghasilkan "Bahasa salah!" Dalam kedua bahasa; juga memiliki baris tambahan, yang tidak termasuk dalam skor):

print("Wrong language!")

Perhatikan bahwa saya menggunakan dialek JavaScript yang tidak biasa di sini. Orang-orang biasanya menggunakan implementasi browser, tetapi mereka memiliki masalah dengan output, melakukannya dengan cara yang aneh (menggunakan alert). Saya menggunakan paket Ubuntu rhinoyang merupakan implementasi JavaScript "offline" dengan sekumpulan perpustakaan yang berbeda diimplementasikan ke browser tipikal (ini dimaksudkan sebagai bahasa skrip yang dapat diembed); ini penting karena memberikan printpernyataan dengan gaya yang sama seperti, misalnya, Python 3.

Ini adalah "polyglot sejati" dalam arti bahwa kedua bahasa menjalankan perhitungan yang sama, dalam urutan yang sama, memberi mereka arti yang sama. Mereka berdua memiliki AST yang sama (dan ini cukup sepele untuk membuat quine polyglot Python 3 + JavaScript melalui pengurangan program ini). Tidak ada kode yang spesifik untuk satu bahasa, yang membantu saya menurunkan panjang. Secara kebetulan, Anda harus menggunakan Python 3 sehingga Anda dapat menggunakan titik koma untuk memisahkan pernyataan (jika Anda menggunakan baris baru, Anda harus keluar dari baris baru).

Program ini dimulai dengan mendefinisikan string sdan dyang masing-masing memegang penawaran tunggal dan ganda. Hal ini memungkinkan untuk menghasilkan kutipan tanpa harus menyebutkannya nanti dalam kode sumber, menghindari masalah dengan melarikan diri (yang sering tampaknya menjadi masalah dengan quine; alasan utama saya menjawab begitu banyak masalah quine di Underload adalah karena string strings-nya) .

Inti dari program adalah array ryang memegang tubuh utama dari dua program yang digunakan oleh tantangan; salah satu program (program yang lebih dulu di program A, dan yang kedua di program B) adalah quine yang hampir menghasilkan program asli melalui penggabungan potongan-potongan (sebagian besar diambil dari rdirinya sendiri, dengan beberapa string literal), dan program cetakan lainnya C. Untuk membuat program ini bukan quine yang sebenarnya (yang akan membuat tidak mungkin untuk mendeteksi bahwa kami menjalankan dalam bahasa yang salah), elemen-elemen rdicetak dalam urutan terbalik; r[0]dalam program A adalah r[1]dalam program B, dan sebaliknya.

Akhirnya, semua yang diperlukan adalah evalmenggunakan elemen yang benar r. Ini dilakukan dengan menggunakan ekspresi ([11]+[0])[1]yang menghasilkan nilai berbeda dalam Python 3 dan dalam JavaScript. Kedua bahasa menguraikannya secara identik, tetapi mereka memiliki gagasan berbeda tentang apa yang ditambahkan ke daftar tambahan:

• Ketika Python 3 menambahkan [11]untuk [0], hal itu akan [11, 0](concatenating daftar), dan kemudian mengambil elemen kedua dari daftar ( [1]) memberi kita bilangan bulat 0.

• Ketika JavaScript menambahkan [11]untuk [0], hal itu akan "110"(concatenating representasi string daftar), dan kemudian mengambil karakter kedua string ( [1]) memberi kita string "1", yang JavaScript cukup senang untuk digunakan sebagai indeks ke dalam daftar.

Oleh karena itu, Python 3 menjalankan elemen pertama rdi kedua program (menghasilkan hampir quine ketika menjalankan program A, dan mencetak program C saat menjalankan program B); JavaScript menjalankan elemen kedua, dan dengan demikian memperlakukan program A dan program B sebaliknya.

Kebetulan, jika Anda menjalankan program A di Ruby, itu akan mencetak program B kecuali tanpa baris baru. Jika Anda menjalankan program B di Ruby, itu akan mencetak program C kecuali tanpa baris baru. Dengan kata lain, solusi ini hampir bekerja dengan sekumpulan bahasa yang berbeda, menukar Python 3 untuk Ruby (satu-satunya alasan saya tidak hanya menghapus baris baru dari program B untuk mendapatkan skor 341 adalah bahwa ketidakkonsistenan baris baru dalam program C akan mendiskualifikasi pengajuan).

(Saya sedang mengerjakan "polyglot sejati" seperti ini karena alasan berbeda, yang sekarang saya posting sebagai tantangan, dan menyadari bahwa tekniknya dapat disesuaikan dengan yang ini juga.)

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

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

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

Program C:

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

Saya menggunakan petunjuk Anda menggunakan C / C ++ dengan Python. Tidak terlalu ringkas, tapi saya rasa masih memenuhi syarat.

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

Saya tidak begitu yakin apakah bagian unichr- replacebagiannya dan dapat golf lebih banyak. Saya mencoba menggunakan Python 3, tetapi banyak yang hilang karena harus menambahkan tanda kurung dan menanganinya. Saya mencoba mengatur R=unicode.replacedan menggunakan itu, tetapi hasilnya menjadi kacau.

Perhatikan bahwa Retina memiliki garis belakang baru dalam outputnya secara default, dan ini tidak termasuk dalam program. Jika seseorang mengatakan saya perlu menghapusnya, itu bisa dilakukan sepele. Selain itu, kode Python berfungsi di repl.it, tetapi tidak dijamin berfungsi di Ideone.com.

Perhatikan juga bahwa memimpin dan mengikuti baris baru sangat penting dalam kode di bawah ini.

Program A (Python 2): 638 587 566 550 byte (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}|^.

Program B (Retina): 735 667 655 645 byte (ISO 8859-1)

Retina , 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

Program C:

Python 2 , Retina

Ini sebenarnya dapat dibuat lebih pendek menggunakan #!`W.*!bukan dua baris terakhir, tetapi ini membuat A dan B lebih lama, karena memiliki `garis di mana tidak ada satu berarti saya harus menanganinya secara berbeda (karena backtick pertama dalam sebuah garis di Retina adalah pembatas konfigurasi).

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

Penjelasan:

Program 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

Saya menulis Program C pertama selama upaya pertama saya dan sebagian besar tetap sama. Dalam Python, ia mencetak string dan mengabaikan komentar. Di Retina, itu tidak menggantikan apa pun dengan print"Wrong language!"dan kemudian menghapus bagian-bagian di sekitar Wrong language!.

Untuk lebih memahami program yang kompleks, mari kita lihat versi yang disederhanakan:

Program A (disederhanakan):

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

Ketika saya mulai dari awal lagi, saya menggunakan PYTHONbit sebagai pengganti untuk kode yang harus mencetak Program A. Versi yang lebih sederhana ini membuatnya lebih mudah untuk menjelaskan bagaimana kedua Program B dan Program C akan dicetak.

Semua yang ada di printdalamnya adalah apa yang mencetak Program B, tetapi pertama-tama, mari kita lihat bagaimana Program C dicetak, karena itu sederhana. Setelah print"..."itu #|. Trik ini menyelamatkan banyak kesulitan yang saya alami dalam upaya pertama saya. Ini memungkinkan Retina untuk mengganti apa pun dengan baris ke-2, yang akan menjadi Program C, kecuali ada #di depan. 2 baris terakhir hapus dulu #. Saya digunakan #{2}untuk mencegah panggung menghapus semua kejadian #. Saya tidak bisa menggunakan #1`#seperti yang saya gunakan di Program B, karena menyebabkan masalah untuk memiliki backtick di baris pertama Program A.

Yang membawa saya ke tugas berikutnya, mencetak Program B. Anda mungkin telah memperhatikan perbedaan lain dari kode aktual. Tidak ada backticks dalam kode aktual, karena saya menggantinya dengan tab. Saya harus mengganti karakter, karena backtick apa pun akan membuat kode sebelumnya string konfigurasi di Retina, menyebabkan sintaks tidak valid. Saya memilih tab karena terlihat dan titik kode adalah satu digit ( 9). Kode mencetak Program B seperti yang ditunjukkan pada versi sederhana di bawah ini.

Program B:

#PYTHON
#1`#

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

Dua baris pertama akan menggantikan apa pun dengan kode Python, tetapi dengan #di depan dan beberapa karakter yang sedikit berbeda. Bagian ini dihilangkan untuk kejelasan. Tahap selanjutnya menghapus itu dulu #. Kemudian, saya menggunakan tahap Transliterasi (T) #T`²-¹`_o`[^¹]untuk membatalkan beberapa replaceoperasi yang terlihat dalam Program A. lengkap. Menggunakan tahap ini adalah cara untuk menghasilkan pilcrow literal ¶di Retina, yang mungkin tidak mungkin. ¹ Menggantikan ·dengan ¶, dan ³dengan ². Kejadian ¹akan tetap sama karena mereka diabaikan [^¹].

Program A:

Baris baru dan tab telah ditambahkan untuk dibaca.

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

Ini mengikuti struktur umum quine Python berikut:

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

Saat Anda menambahkan sesuatu sebelum atau sesudah, Anda harus memasukkannya ke dalam string juga.

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

Saya ingin menggunakan string yang dikutip tiga kali lipat agar mudah menyertakan tanda kutip (menghindari penggunaan garis miring terbalik). s=U(39)*3;adalah string '''. Saya juga menggunakan %salih-alih %r, untuk menghindari beberapa masalah dengan baris baru atau karakter lain yang lolos dengan garis miring terbalik.

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

Jadi sekarang, penggantian. Penggantian pertama .replace(U(9),U(96));ada untuk mengganti tab dengan backticks yang kita lihat di Program B. Penggantian ini dilakukan sebelum pemformatan string, karena tab perlu tetap tab di Program A. Penggantian lainnya hanya untuk menghindari penggunaan karakter tertentu dalam 2 jalur Program 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

Tiga penggantian terakhir ini mengantisipasi tahap Transliterasi dalam Program B, untuk mencegah agar karakter-karakter tersebut tidak dihapus atau ditransliterasi padahal seharusnya tidak.

Satu-satunya bagian lain dari kode adalah kode dari Program B yang pada dasarnya disalin karakter-untuk-karakter, kecuali untuk perubahan karena penggantian.

¹ Terima kasih kepada Martin untuk tipnya tentang cara mengeluarkan literal ¶di Retina. Itu membuat semuanya jadi lebih mudah.

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

Program A: Coba di Befunge | Coba dengan 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:]'''

Program B: Coba dengan Python | Coba di 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:]'''"""

Program C: Coba di Befunge | Coba dengan Python

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

Penjelasan

Program C: Ini bergantung pada kenyataan bahwa Befunge-93 mengabaikan instruksi yang tidak didukung, jadi sementara yang ptidak berbahaya menulis nol pada 0; 0, sisanya printdiabaikan hingga <instruksi yang membalikkan arah. Kemudian mengalir dari kanan ke kiri, +5+5mendorong 10 (linefeed) ke stack diikuti oleh string pesan, dan kemudian urutan output standar dieksekusi untuk menulis string. Dalam Python itu hanya mencetak dua string literal yang digabungkan bersama-sama, tetapi yang pertama (berisi kode Befunge) dipotong oleh referensi array di akhir ( [+5+5:]).

Program B: Baris pertama adalah urutan Befunge yang cukup mendasar untuk mencetak Program C. Satu-satunya hal yang menarik adalah bagaimana ia menghasilkan karakter kutipan menggunakan 50g(yaitu membaca karakter dari memori) yang lebih efisien daripada menghitung kode ASCII. The #>(jembatan di atas instruksi arah) pada dasarnya adalah sebuah nop yang mencegah kode yang dilihat oleh Python sejak #adalah Python komentar karakter. Interpretasi Python dimulai pada baris dua dan hanya mencetak string multiline yang berisi kode sumber Program A.

Program A: Dalam Python, tiga baris pertama sekali lagi diabaikan karena mereka mulai dengan #, sedangkan baris terakhir hanya mencetak Program C. Kode Befunge bolak-balik melintasi tiga baris pertama, membangun sumber untuk Program B pada stack dalam urutan terbalik. Dimulai dengan tiga tanda kutip, kemudian urutan yang membuat salinan dari sumber Program A, dan akhirnya apa yang pada dasarnya adalah string kode keras dengan pembukaan print """dan baris pertama kode Befunge. Maka hanya masalah menuliskannya dengan urutan output standar.

Beberapa poin pertikaian:

1. Saya telah diberitahu bahwa quine menggunakan gperintah tidak dianggap quine yang tepat sejauh yang menyangkut komunitas ini. Saya tidak yakin apakah aturan itu akan berlaku untuk tantangan ini juga, tetapi jika demikian, jawaban ini mungkin tidak dianggap sebagai solusi yang tepat juga.

2. Meskipun saya telah mengatakan bahwa Befunge-93 mengabaikan instruksi yang tidak didukung, itu tidak didefinisikan secara teknis dalam spesifikasi, dan Anda harus menggunakan -qopsi baris perintah (senyap) dalam juru bahasa referensi untuk menghindari peringatan dalam Program C. Kebanyakan penerjemah lain akan baik-baik saja, tetapi beberapa flakier berpotensi crash. Perhatikan juga bahwa Befunge-98 mencerminkan instruksi yang tidak didukung, sehingga penerjemah 98 hanya akan mengulang tanpa batas.

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

Jangan berpikir saya bisa berbagi 52 byte dari mekanisme yang mendasari karunia, tapi saya senang membangun ini. Saya pikir apa yang saya hasilkan memenuhi kriteria ...

Program 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($_)

Program 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($_)

Program 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($_)

Penjelasan

Menggunakan polyquine Perl / JavaScript saya sebagai basis tetapi menetapkan variabel tambahan $Pyang mengontrol program mana yang akan dihasilkan. Menggunakan cek yang +[]benar di Perl, namun salah dalam JavaScript.