Створіть програму 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

Програма С

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

><>:
" Wrapping string literal
 a0!#. Jump to cell 10,0
           f[ Create a new stack with only the top 15 elements
             >o< Print stack

Befunge-98:
" Wrapping string literal
 a0!#. Push 10,1
      p Pop 10,1 and excess space
       ek,@ Push 14 and execute , 14+1 times and exit the program

JavaScript (ES6) / Python 3, 264 + 258 = 522 байти

Програма A:

a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";c="1//2;alert=print\nalert('Wrong language!')";1//2;print(c);'''
console.log(b,...[a,b,c].map(uneval))//'''

Програма B:

a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";c="1//2;alert=print\nalert('Wrong language!')";1//2;'''
print=_=>console.log(c)//'''
print(a%(a,b,c))

Програма C:

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

Можливо, пограє ...

Пояснення JavaScript

Програма A:

// Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

// Ignore this line:
1//2;print(c);'''

// Print the Python program (b), replacing the "%s"s with the raw forms of a, b, and c:
console.log(b,...[a,b,c].map(uneval))//'''

Програма B:

// Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

// Ignore this line:
1//2;'''

// Define a function `print` which prints `c` (the "Wrong language!" program):
print=_=>console.log(c)//'''

// Call `print`, ignoring the argument (which is NaN):
print(a%(a,b,c))

Програма C:

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

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

Пояснення Python

Програма A:

# Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

# Print `c` (the "Wrong language!" program):
1//2;print(c);

# Ignore this part:
'''
console.log(b,...[a,b,c].map(uneval))//'''

Програма B:

# Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

# Ignore this part:
1//2;'''
print=_=>console.log(c)//'''

# Print the JS program (a), replacing the "%r"s with the raw forms of a, b, and c:
print(a%(a,b,c))

Програма C:

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

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

Python 3 + JavaScript (Rhino), 171 + 171 = 342 байт

Програма A (виводить програму 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 за допомогою скорочення цієї програми досить тривіально). Не існує коду, характерного для однієї мови, який допомагає мені зменшити довжину шляху. Між іншим, вам потрібно використовувати Python 3, щоб ви могли використовувати крапки з комою для розділення висловлювань (якщо ви використовували нові рядки, вам слід було б уникнути нових рядків).

Програма починається з визначення рядків sі dякі утримують одинарні лапки і подвійні лапки відповідно. Це дає змогу виводити лапки без необхідності згадувати їх пізніше у вихідному коді, уникаючи проблем із втечею (що часто здається проблемою з лайками; головна причина, за яку я відповідаю на стільки проблем квот у Underload, це те, що його рядки гніздяться) .

Серцем програми є масив, rякий містить основну частину двох програм, використовуваних викликом; одна з програм (перша, що надходить першою в програмі A, а друга - у програмі B) - це майже квент, яка просто виводить оригінальну програму шляхом об'єднання об'єднаних фрагментів (взятих здебільшого з rсебе, з кількома рядковими буквами), і інші програми для друку C. Для того, щоб програма не була справжньою квинею (яка б унеможливила виявити, що ми працювали невірною мовою), елементи rдрукуються у зворотному порядку; r[0]у програмі A - r[1]у програмі B, і навпаки.

Нарешті, все, що потрібно, - це evalвикористовувати правильний елемент r. Це здійснюється за допомогою виразу, ([11]+[0])[1]який створює інше значення в Python 3 та JavaScript. Обидві мови розбирають її однаково, але вони мають різні уявлення про те, що додавання до списків:

• Коли Python 3 додає [11]до [0], він отримує [11, 0](об'єднання списків), а потім, беручи другий елемент списку ( [1]), дає нам ціле число 0.

• Коли JavaScript додає [11]до [0], він отримує "110"(конкатенації строкових уявлень списків), а потім приймати другий символ рядка ( [1]) дає нам рядок "1", яка JavaScript цілком щасливі використовувати в якості індексу в список.

Отже, Python 3 запускає перший елемент rобох програм (виробляючи майже a-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деталі можуть бути golfed більше. Я спробував використовувати 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 (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:

Пітон 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

Я написав Програму С під час своєї першої спроби і зберіг її здебільшого. У Python він друкує рядок і ігнорує коментар. У Retina вона нічого не замінює, print"Wrong language!"а потім видаляє частини навколо Wrong language!.

Щоб краще зрозуміти складні програми, давайте розглянемо спрощені версії:

Програма A (спрощена):

print"\n#PYTHON\n#1`#\n\n#T`²-¹`_o`[^¹]\nn=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n\n"#|
#¶print"Wrong language!"¶#?.*t|"¶
#{2}|^.

Коли я почав з нуля, я використав PYTHONбіт як заповнювач для коду, який повинен надрукувати Програму А. Ця простіша версія спростила пояснення, як друкуються і Програма B, і Програма C.

printІ все всередині , що друкує програма B, але перший, давайте подивимося , як програма C друкується, тому що це просто. Після того, як print"..."є #|. Цей трюк врятував ЗАВАНТАЖЕННЯ труднощів, які я відчув у першій спробі. Це дозволяє Retina нічого не замінювати другим рядком, який буде Програмою C, за винятком того, що є #спереду. Останні 2 рядки видаляють цей перший #. Я використовував, #{2}щоб запобігти видаленню всіх подій #. Я не можу використовувати так, #1`#як я використовував у програмі B, оскільки це призводить до проблем із тим, що цей зворотний зв'язок у першому рядку програми А.

Що підводить мене до мого наступного завдання, друкуючи програму 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операцій бачили в повній програмі А. Використовуючи цей етап є способом виведення буквальний знак абзацу ¶в сітківці, які в іншому випадку могли б бути 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. Ця заміна проводиться перед форматуванням рядків, оскільки вкладки повинні залишатися вкладками в програмі А. Інші заміни - це просто уникнути використання певних символів у 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 / Python, 381 + 485 259 + 345 229 + 304 = 533 байти

Програма A: Спробуйте в Befunge | Спробуйте в Python

#>21g::35*:*::":"%\>:#$":"%#\ \#%":"/#::$#-g#1\_#+\#5:#5_v
#v"50g"g12"'<:#>!#,_@<'tnirp"g12">:#,_@"+55"print "::g12$<
#>21g"Wrong language!"21g"g05"21g"[+5+5:]"21g"+55>#">:#,_@
print'''print'<@_,#!>#:<'"Wrong language!"[+5+5:]'''

Програма B: Спробуйте в Python | Спробуйте в Бефунге

#>55+"]:5+5+["50g"!egaugnal gnorW"50g"'<:#>!#,_@<'tnirp">:#,_@
print """#>21g::35*:*::":"%\>:#$":"%#\ \#%":"/#::$#-g#1\_#+\#5:#5_v
#v"50g"g12"'<:#>!#,_@<'tnirp"g12">:#,_@"+55"print "::g12$<
#>21g"Wrong language!"21g"g05"21g"[+5+5:]"21g"+55>#">:#,_@
print'''print'<@_,#!>#:<'"Wrong language!"[+5+5:]'''"""

Програма C: Спробуйте в Befunge | Спробуйте в Python

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

Пояснення

Програма C: Це спирається на той факт, що Befunge-93 ігнорує непідтримувані вказівки, тому, поки pнешкідливий запис нуля становить 0; 0, решта printігнорується до тих пір, поки <інструкція не змінить напрямок. Потім, протікаючи справа наліво, +5+5натискає на 10 (рядок передачі рядка) на стек, за яким йде рядок повідомлення, а потім виконується стандартна послідовність виводу для запису рядка. У Python це просто друк двох рядкових літералів, об'єднаних разом, але перший (містить код Befunge) відрізається посиланням масиву в кінці ( [+5+5:]).

Програма B: Перший рядок - це досить основна послідовність Befunge для друку програми C. Єдине, що цікаво - це спосіб генерування символів цитат за допомогою 50g(тобто зчитування символу з пам'яті), що є більш ефективним, ніж обчислення коду ASCII. #>(Міст через інструкцію напрямки) є по суті NOP , що перешкоджає коду бути побаченим Python , оскільки #це символ коментаря Python. Інтерпретація Python починається з другого рядка і просто друкує рядковий рядок, що містить вихідний код програми A.

Програма A: У Python перші три рядки знову ігноруються, оскільки вони починаються з #, тоді як останній рядок просто роздруковує програму C. Код Befunge зміюється вперед і назад по перших трьох рядках, будуючи джерело програми B на стеку у зворотному порядку. Він починається з трьох лапок, потім послідовності, яка робить копію джерела програми A, і, нарешті, те, що по суті є жорстко кодованою рядком з відкриттям print """і першим рядком коду Befunge. Тоді лише питання виписати його зі стандартною послідовністю виводу.

Деякі суперечки:

1. Мені сказали, що quine, що використовує gкоманду, не вважається належним 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.