В свое время на PPCG я заметил, что проблемы с квин и полиглоты довольно популярны. Кроме того, мета-решения проблем, то есть сценарии, которые генерируют программу, которая является решением проблемы, имеют тенденцию получать много положительных отзывов от сообщества. Поэтому я создал этот вызов, который реализует эти три идеи.

Ваша задача, читатель и энтузиаст кода , состоит в том, чтобы создать как можно более короткий сценарий, который может работать на двух языках A и B, чтобы генерировать квин для A и B. Когда ваша программа запускается на языке A, она должна сгенерировать программа, которая является quine на языке B, но не на языке A и наоборот. Языки A и B могут быть разными версиями одного и того же языка, при условии, что вы помните, что сгенерированные quines должны работать только в одной из версий.

Имейте в виду, что стандартные лазейки следует считать закрытыми и разрешены только надлежащие квины .

Удачи, побеждает меньшее количество персонажей!

CJam 0.6.6 dev / GolfScript, 15 14 12 байт

"0$p"0$~a:n;

Спасибо @ jimmy23013 за 2 байта в гольфе!

Остальные будут обновлены.

верификация

Так как представление включает в себя значительные пробелы, лучше всего сравнивать hexdumps.

$ xxd -g 1 mpquine
0000000: 22 60 30 24 7e 22 30 24 7e 4e 4d 3a 6e 3b        "`0$~"0$~NM:n;
$
$ cjam mpquine | tee quine.gs | xxd -g 1
0000000: 22 60 30 24 7e 22 60 30 24 7e 0a                 "`0$~"`0$~.
$ golfscript quine.gs | xxd -g 1
0000000: 22 60 30 24 7e 22 60 30 24 7e 0a                 "`0$~"`0$~.
$ cjam quine.gs | xxd -g 1
0000000: 22 60 30 24 7e 22 60 30 24 7e                    "`0$~"`0$~
$
$ golfscript mpquine | tee quine.cjam | xxd -g 1
0000000: 22 60 30 24 7e 22 60 30 24 7e                    "`0$~"`0$~
$ cjam quine.cjam | xxd -g 1
0000000: 22 60 30 24 7e 22 60 30 24 7e                    "`0$~"`0$~
$ golfscript quine.cjam | xxd -g 1
0000000: 22 60 30 24 7e 22 60 30 24 7e 0a                 "`0$~"`0$~.

CJam

CJam печатает "`0$~"0$~и завершает перевод строки. Попробуйте онлайн!

Сгенерированная программа печатает "`0$~"0$~с завершающим переводом строки в GolfScript ( Попробуйте онлайн! ), Но без перевода строки в CJam ( Попробуйте онлайн! ).

Как работает метахин

"`0$~"         e# Push that string on the stack.
      0$~      e# Push a copy and evaluate it:
               e#   `     Inspect the string, pushing "\"`0$~\"".
               e#    0$   Push a copy.
               e#      ~  Evaluate, pushing "`0$~".
               e# Both "\"`0$~\"" and "`0$~" are now on the stack.
         NM    e# Push "\n" and "".
           :n; e# Map print over the elements of "" (none) and pop the result.
               e# "\"`0$~\"", "`0$~", and "\n" are now on the stack, and the
               e# characters they represent will be printed implicitly.

Как работает квайн

"`0$~"          # Push that string on the stack.
      0$~       # As in CJam.
         <LF>   # Does nothing.
                # "\"`0$~\"" and "`0$~" are now on the stack, and the characters
                # they represent will be printed implicitly, plus a linefeed.

В отличие от GolfScript, CJam по умолчанию не печатает завершающий перевод строки, поэтому в CJam это не quine.

GolfScript

GolfScript печатает "`0$~"0$~без пробела. Попробуйте онлайн!

Сгенерированная программа печатает "`0$~"0$~без пробела в CJam ( Попробуйте онлайн! ), Но GolfScript добавляет перевод строки ( Попробуйте онлайн! ).

Как работает метахин

"`0$~"0$~       # As in CJam.
         NM     # Unrecognized token. Does nothing.
           :n   # Store the top of the stack – "`0$~" – in the variable n. n holds
                # "\n" by default. When the program finishes, the interpreter
                # prints n implicitly, usually resulting in a trailing linefeed.
                # By redefining n, it will print "0$~" instead.
             ;  # Pop the string from the stack so it won't be printed twice.

Как работает квайн

"`0$~"0$~      e# Works as in GolfScript.

В отличие от CJam, GolfScript добавит перевод строки к содержимому стека, поэтому в GolfScript это не квинна.

CJam / Fission, 22 байта

"'!+OR'")5-"{'_'~}_~";

Попробуйте это в CJam. Попробуйте это в Fission.

В CJam это печатает стандартную квиншу деления :

'!+OR"

Попробуйте Quine Fission.

В Fission это печатает "без-стандартный вариант стандартной CJam quine:

{'_'~}_~

Попробуйте CJam Quine.

Это также работает для 22 байтов (печать тех же самых строк):

"& *NQ!":)R"{'_'~}_~";

объяснение

В CJam:

"'!+OR'"    e# Push this string.
)           e# Pull off the last character.
5-          e# Subtract 5, turning ' into ".
"{'_'~}_~"  e# Push this string.
;           e# And discard it again.

Таким образом, в конце программы, стек содержит строку "'!+OR"и символ ", оба из которых печатаются неявно.

При делении программный поток начинается Rс правостороннего атома. '"только изменения массы атомов, ), 5и -игнорируются по разным причинам. Затем атом переходит в режим печати "и печатает {'_'~}_~. ;уничтожает атом и завершает программу.

Clojure / Common Lisp, 274 байта

(defmacro t []"((fn [s] (print (list s (list (quote quote) s)))) (quote (fn [s] (print (list s (list (quote quote) s))))))")(if '()(print(let[s clojure.string/replace](.toUpperCase(s(s(s(s(s(t)"fn""lambda")"[s]""(s)")"(quote ""'")"e)""e")")))))""))))"))))(eval '(princ(t))))

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

(defmacro t []"((fn [s] (print (list s (list (quote quote) s))))
     (quote (fn [s] (print (list s (list (quote quote) s))))))")
(if '()(print(let[s clojure.string/replace](.toUpperCase
    (s(s(s(s(s(t)"fn""lambda")"[s]""(s)")"(quote ""'")"e)""e")")))))""))))"))))
    (eval '(princ(t))))

В основном определяет макрос, который возвращает quine в Clojure. Для Clojure требуются параметры для определения макроса в виде вектора ( []), тогда как Common Lisp (к счастью) просто игнорирует его. После этого мы различаем два языка, оценивая, '()что равно nilи, следовательно, ложно в Common Lisp и находится trueв Clojure. Затем мы выполняем строковые манипуляции с использованием Clojure, которые Common Lisp даже не пытается оценить, как это происходит в другой ifветке. С другой стороны, Clojure пытается проверить, является ли другая ветвь, по крайней мере, правильной перед выполнением, поэтому пришлось использовать ее, evalчтобы быть корректной в Clojure и выводить правильную строку в Common Lisp.

Примечание: простое возвращение двух разных строк может быть короче, но это не будет отличаться от проблем полиглота, связанных с выводом разных строк на разных языках. ¯ \ _ (ツ) _ / ¯

Оригинальный исходный код Clojure: https://ideone.com/SiQhPf

Общий исходный код Common Lisp: https://ideone.com/huLcty

Clojure выход: ((LAMBDA (S) (PRINT (LIST S (LIST 'QUOTE S)))) '(LAMBDA (S) (PRINT (LIST S (LIST 'QUOTE S)))))

Общий вывод на Лиспе: ((fn [s] (print (list s (list (quote quote) s)))) (quote (fn [s] (print (list s (list (quote quote) s))))))

Вывод Clojure выполняется в Common Lisp: https://ideone.com/T1DF7H

Наоборот: https://ideone.com/Fezayq

Jelly / GolfScript, 18 16 байт

0000000: 3a 6e 22 ff cc cc 22 7d 7f fe 22 3a 6e 60 ff 3b  :n"..."}..":n`.;

верификация

Тестирование всех участвующих программ с точными потоками байтов может быть сделано только локально.

$ LANG=en_US # Latin-1. Jelly doesn't care about the exact encoding,
$            # as longs as it's not UTF-8.
$
$ xxd -g 1 mpquine
0000000: 3a 6e 22 ff cc cc 22 7d 7f fe 22 3a 6e 60 ff 3b  :n"..."}..":n`.;
$
$ jelly f mpquine | tee quine.gs | xxd -g 1
0000000: 22 3a 6e 60 22 3a 6e 60                          ":n`":n`
$ golfscript quine.gs | xxd -g 1
0000000: 22 3a 6e 60 22 3a 6e 60                          ":n`":n`
$ jelly f quine.gs 2> /dev/null | xxd -g 1
$
$ golfscript mpquine | tee quine.jelly | xxd -g 1
0000000: ff cc cc                                         ...
$ jelly f quine.jelly | xxd -g 1
0000000: ff cc cc                                         ...
$ golfscript quine.jelly | xxd -g 1
0000000: 0a

Желе

С кодовой страницей желе программа выглядит следующим образом.

:n"”ṘṘ"}
“":n`”;

Это печатает ( Попробуйте онлайн! )

":n`":n`

это квинна в GolfScript ( попробуйте онлайн! ), но ошибка парсера в Jelly ( попробуйте онлайн! ).

GolfScript

На латинице 1 программа выглядит следующим образом с непечатаемым символом DEL между }и þ.

:n"ÿÌÌ"} þ":n`ÿ;

Это печатает ( Попробуйте онлайн! )

ÿÌÌ

или, визуализированный с помощью кодовой страницы желе,

”ṘṘ

который является квиной в Jelly ( попробуйте онлайн! ), но печатает только перевод строки в GolfScript ( попробуйте онлайн! ).

JavaScript / C 278 байт

При ошеломляющих 278 байтах:

//\
console.log('int main(){char*A="int main(){char*A=%c%s%c;printf(A,34,A,34);}";printf(A,34,A,34);}');/*
int main(){puts("A='A=;B=String.fromCharCode(39);console.log(A.slice(0,2)+B+A+B+A.slice(2));';B=String.fromCharCode(39);console.log(A.slice(0,2)+B+A+B+A.slice(2));");}//*/

C-quine:

int main(){char*A="int main(){char*A=%c%s%c;printf(A,34,A,34);}";printf(A,34,A,34);}

JavaScript-квин:

A='A=;B=String.fromCharCode(39);console.log(A.slice(0,2)+B+A+B+A.slice(2));';B=String.fromCharCode(39);console.log(A.slice(0,2)+B+A+B+A.slice(2));

Befunge / Fission, 35 байт

"$TQ-#'">,#-:#2_@;"+1_@#`+66:,g0:"L

Попробуйте это в Befunge | Попробуй это в Fission

В Befunge это создает квин Fission :

'!+OR"

В Fission это производит Quine Befunge :

:0g,:66+`#@_1+

Python / Retina, 70 65 64 66 байт

Я использовал ту же стратегию, что и в предыдущем полиглоте Python / Retina .

#
print"\nS`((.+))"*2+"\n\n"
#?
#_='_=%r;%_\n';_
#?;
#;print _%
#

Попробуй в Python | Попробуй в Retina

#это комментарий в Python, поэтому он просто печатает квинту Retina в Python. В Retina первый этап (2 строки) ничего не делает, потому #что на входе ничего не будет найдено. На следующем этапе ничего не заменяется основой quine Python. Третий этап заменяет каждую точку с запятой на #print _%часть. Последний этап удаляет все #.

Куайн в сетчатке:

S`((.+))
S`((.+))

Quine в Python:

_='_=%r;print _%%_\n';print _%_

Используемые квины можно увидеть в этом испытании . Quine Retina является ошибкой в ​​Python, а Quine Python не выводит в Retina.

Python 3 / Python 2, 62 байта

_='_=%r;print(_%%_['+'~'*-~int(-1/2)+'int(-1/2):])';print(_%_)

Попробуйте это в Python 2 , Python 3 .

Основано на Quine Python здесь . Различающий фактор между двумя версиями заключается в том, что они делают int(-1/2): в Python 2 /- целочисленное деление (округление вниз) с результатом -1; в Python 3 /- это деление с плавающей точкой ( -0.5), которое intусекается до 0.

Мы строим строку _из трех частей. '_=%r;print(_%%_['и 'int(-1/2):])'всегда одинаковы. Интересная часть '~'*-~int(-1/2):

• В Python 2 -~int(-1/2)есть 0, и тильда не добавляется в строку;
• В Python 3 -~int(-1/2)есть 1, и тильда добавляется в строку.

Таким образом, Python 2 выводит строку Python 3

_='_=%r;print(_%%_[int(-1/2):])';print(_%_[int(-1/2):])

и Python 3 выводит Quine Python 2

_='_=%r;print(_%%_[~int(-1/2):])';print(_%_[~int(-1/2):])

В каждой версии выражение внутри [ :]оценивается как 0, что заставляет срез включать всю строку, тогда как на неправильном языке оно оценивает -1, что заставляет срез включать только последний символ, обрезая вывод, так что это не полная квинна.

Brain-Flak , brainfuck 4617 4009 байт

((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()()()())))()())[()()])))()()())[()()])))())[()])[()()()()])))))))))))))))))))))))))))))))))))))))))))()()())()())[()()()()])()()())[()()])()())[()()()()])()()()))()()())[()()])[()()()()])))))))))))))))))))()())))()()())[()()()()])()()()()())[()()]))()())[()()()])()())[()()])))()()())[()()])))())[()()])[()()()])))))))))))))))))))))))))))))))))))))))))))()()()())[()()()])()()()())[()()])[()()()]))()()()())[()()()])()()()())[()()])[()()()])()()()())[()()()])()()()())[()()])[()()()]))))))))))))))()()()())[()()()])()()()())[()()])[()()()]))()()()())[()()()])()()()())[()()])[()()()])))))))))))))))))))))))))))))()()()())[()()()])()()()())[()()])[()()()]))()()()())[()()()])()()()()()))))))[()()()])[()])()()))))()()){({}<>)<>}<>([]){({}[()]<(({}[()]<((((((()()()){}())){}{}){}())<>)>)<>){({}[()]<({}()())>){({}[()]<({}())>){({}[()]<({}((()()()){}()){})>){({}[()]<({}()())>){({}[()]<({}(((()()()){}()){}){}())>){(<{}({}()())>)}}}}}}{}([]<({}<{({}<>)<>}<>>)>){({}[()]<({}<>)<>>)}{}{({}[()]<(({}))>)}{}(((({})(((()()())){}{}){}())))<>>)}{}{<>({}<>)}{+++++++>>>+>>>+++++++>>>++++++++>>>+++>>>++++>>>++>>>+++>>>++++>>>++++++++>>>+++>>>++++>>>+>>>+++++>>>++++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+>>>+>>>+>>>+>>>+>>>+>>>+>>>+>>>++>>>+>>>++>>>+>>>++>>>+>>>++>>>+>>>++>>>++>>>+++++++>>>++++++++>>>++>>>+++++++>>>++++++++>>>++>>>+++++++>>>++++++++>>>++>>>+++>>>++++>>>++>>>++>>>+>>>++>>>++>>>++>>>++++>>>++>>>+++>>>++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+>>>++>>>++>>>++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+>>>+>>>+>>>+>>>++>>>+>>>++>>>+>>>++>>>++>>>++>>>+++++++>>>++++++++>>>+++++++>>>++++++++>>>++>>>+++++++>>>++++++++>>>+>>>++>>>++>>>++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+>>>++>>>+>>>++>>>++>>>++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+>>>+>>>+>>>+>>>++>>>+>>>++>>>+>>>++>>>++>>>+++++++>>>++++++++>>>+>>>++>>>++>>>+++++++>>>++++++++>>>++>>>+++++++>>>++++++++>>>+>>>++>>>++>>>++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+>>>++>>>+>>>++>>>++>>>++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+>>>+>>>+>>>+>>>++>>>+>>>++>>>+>>>++>>>+>>>++>>>+>>>++>>>++>>>++>>>+++++++>>>++++++++>>>+++++++>>>++++++++>>>++>>>+++++++>>>++++++++>>>++>>>++++>>>++>>>+++++++>>>+>>>+++>>>+++++++>>>++++++++>>>+>>>+++++++>>>++++++++>>>+>>>++>>>+>>>++>>>++>>>++++>>>++>>>++++++++>>>++++++++>>>++++++++>>>++++++++>>>++++++++>>>++++++++>>>++++++++>>>+++++++>>>++++++++>>>+>>>+++++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++>>>++++>>>++>>>+++>>>++++>>>++++++++>>>+++>>>++++>>>++++>>>++>>>++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+++>>>++++>>>++>>>+++>>>++++>>>++++>>>++>>>++++++++>>>+++++++>>>++++++++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>++>>>+>>>++>>>++>>>++>>>++++>>>++>>>++++++++>>>+++++++>>>++++++++>>>+++>>>++++>>>++++>>>++>>>++++++++>>>+++++++>>>++++++++>>>+++>>>++++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++>>>++++>>>++>>>+++>>>++++>>>++++++++>>>+++>>>++++>>><<<[<<<]>>>[>++++++++++++++++++++++++++++++++++++++++.<[->.+.->+<<]>+.[-]>>]<[<<<]>>>[<++++++++++++++++++++++++++++++++++++++++>-[<+>-[<+++++++++++++++++++>-[<++>-[<+++++++++++++++++++++++++++++>-[<++>-[<++++++++++++++++++++++++++++++>-[<++>-]]]]]]]<.>>>>]}{}

Попробуйте онлайн!

Попробуйте онлайн!

Объяснение уже в пути Я все еще играю в гольф