Создайте программу 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 байтов} + {b байтов} = {всего байтов} байтов

Программа А:

a code

Программа Б:

b code

Программа С:

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 / другие #комментируемые языки] являются хорошими комбинациями, потому что вы можете определить макросы, которые один язык может игнорировать

Это код-гольф , поэтому выигрывает наименьшая сумма байтов в программах А и В.

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=%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))//'''

Программа Б:

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

Программа С:

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

Возможно, гольф ...

Объяснение JavaScript

Программа А:

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

Программа Б:

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

Программа С:

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

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

Объяснение Python

Программа А:

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

Программа Б:

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

Программа С:

# 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которые удерживают одинарные кавычки и двойные кавычки соответственно. Это позволяет выводить кавычки, не упоминая их позже в исходном коде, избегая проблем с экранированием (которые часто кажутся проблемами с квин; ,

Сердцем программы является массив, rкоторый содержит основную часть двух программ, используемых в задании; одна из программ (та, которая идет первой в программе A, и вторая в программе B) - это почти quine, которая просто выводит исходную программу посредством объединения частей (взятых в основном из rсебя, с несколькими строковыми литералами), и другие печатает программу C. Чтобы сделать программу не истинной формулой (что не позволило бы обнаружить, что мы работали на неправильном языке), элементы rпечатаются в обратном порядке; r[0]в программе А находится r[1]в программе Б, и наоборот.

Наконец, все, что нужно, это 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в обеих программах (создание почти-quine при запуске программы A и печать программы C при запуске программы B); JavaScript запускает второй элемент и, таким образом, обрабатывает программу A и программу B противоположным образом.

Между прочим, если вы запустите программу A на Ruby, она напечатает программу B, за исключением завершающего перевода строки. Если вы запустите программу B в Ruby, она напечатает программу C, за исключением завершающего перевода строки. Другими словами, это решение почти работает с другим набором языков, заменяя Python 3 на Ruby (единственная причина, по которой я не просто удаляю новую строку из программы B, чтобы получить оценку 341, заключается в том, что несоответствие новой строки в программе C будет дисквалифицировать представление).

(Я работал над «настоящим полиглотом», подобным этому, по другой причине, которую я сейчас опубликовал как вызов, и понял, что методы могут быть адаптированы и к этой.)

C / Python, 733 байта + 733 байта = 1466 байтов

Программа А:

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

Программа Б:

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

Программа С:

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

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)

Сетчатка , Питон 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

Программа С:

Python 2 , Retina

На самом деле это можно сделать короче, используя #!`W.*!вместо двух последних строк, но это делает А и В длиннее, потому что наличие `в строке, где не было ни одного, означает, что мне нужно обрабатывать это по-другому (потому что первый обратный удар в строке в Retina это разделитель конфигурации).

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

Объяснение:

Программа С:

                        # 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 он печатает строку и игнорирует комментарий. В Retina он ничего не заменяет, print"Wrong language!"а затем удаляет части вокруг Wrong language!.

Чтобы лучше понять сложные программы, давайте рассмотрим упрощенные версии:

Программа А (упрощенная):

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 бит в качестве заполнителя для кода, который должен печатать Программу А. Эта более простая версия упростила объяснение того, как будут печататься и Программа В, и Программа С.

Все printи внутри - это то, что печатает Программу B, но сначала давайте посмотрим, как печатается Программа C, потому что это просто. После того, print"..."как #|. Этот трюк спас НАГРУЗКИ от трудностей, которые я испытал в своей первой попытке. Это позволяет Retina ничего не заменять на 2-ю строку, которая будет программой C, за исключением того, что есть #перед. Последние 2 строки удаляют это первым #. Я использовал, #{2}чтобы предотвратить удаление сцены все случаи #. Я не могу использовать, #1`#как я использовал в Программе B, потому что это вызывает проблемы с тем, что в первой строке Программы A.

Это подводит меня к следующему заданию - распечатка программы B. Возможно, вы заметили другое отличие от реального кода. В самом коде нет обратных галочек, так как я заменил их на вкладки. Я должен был заменить символ, потому что любой обратный удар мог бы сделать предыдущий код строкой конфигурации в Retina, что привело бы к тому, что синтаксис был недействительным. Я выбрал вкладки, потому что они видны, а кодовая точка состоит из одной цифры ( 9). Код печатает Программу B, как показано в упрощенной версии ниже.

Программа Б:

#PYTHON
#1`#

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

Первые две строки ничего не заменят на код Python, но на #передний, а некоторые символы немного отличаются. Эта часть опущена для ясности. Следующий этап удаляет это первым #. Затем я использую этап транслитерации (T) , #T`²-¹`_o`[^¹]чтобы отменить некоторые из replaceопераций видели в полной программе А. Используя этот этап является способом вывода буквальный знак абзаца ¶в сетчатке, которые в противном случае могли бы быть impossible.¹ Он заменяет ·с ¶, и ³с ², Появления ¹останутся такими же, потому что их игнорируют [^¹].

Программа А:

Новые строки и вкладки были добавлены для удобства чтения.

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, который по сути копируется символ за символом, за исключением изменений, вызванных заменами.

¹ Благодаря Мартину за его кончик о том , как выводить буквальное ¶в сетчатке. Это сделало все намного проще.

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:]'''

Программа Б: Попробуйте на 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 (перевод строки) в стек, за которым следует строка сообщения, а затем выполняется стандартная выходная последовательность для записи строки. В Python он просто печатает два строковых литерала, которые объединяются вместе, но первый (содержащий код Befunge) обрезается ссылкой на массив в конце ( [+5+5:]).

Программа B: Первая строка - это довольно простая последовательность Befunge для распечатки Программы C. Единственная интересная вещь - это то, как она генерирует символы кавычек с помощью 50g(т. Е. Читает символ из памяти), что более эффективно, чем вычисление кода ASCII. #>(Мост через инструкцию направления) является по существу NOP , что препятствует коду быть увиденным Python , поскольку #это символ комментария Python. Интерпретация Python начинается со второй строки и просто печатает многострочную строку, содержащую исходный код Программы А.

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

Некоторые спорные вопросы:

1. Мне сказали, что квин, использующий gкоманду, не считается подходящим квинем, насколько это сообщество обеспокоено. Я не уверен, применимо ли это правило и к этой проблеме, но если так, то этот ответ также не может считаться правильным решением.

2. Хотя я и сказал, что Befunge-93 игнорирует неподдерживаемые инструкции, это технически не определено в спецификации, и вам нужно будет использовать -q(тихую) опцию командной строки в ссылочном интерпретаторе, чтобы избежать предупреждений в программе C. Большинство других интерпретаторов будут хотя все будет хорошо, но некоторые из них могут потерпеть крах. Также обратите внимание, что Befunge-98 отражает неподдерживаемые инструкции, поэтому интерпретатор 98 будет просто зацикливаться бесконечно.

Perl / JavaScript, 176 байт + 176 байт = 352 байт

Не думаю, что я могу поделиться 52 байтами с базовым механизмом для награды, но мне понравилось строить это. Я думаю, что то, что я произвел, соответствует критериям ...

Программа А:

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

Программа Б:

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

Программа С:

$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.