W czasie mojej pracy nad PPCG zauważyłem, że problemy z quine i polyglot są dość popularne. Również meta-rozwiązania problemów, czyli skrypty, które generują program będący rozwiązaniem problemu, zwykle uzyskują wiele pozytywnych opinii od społeczności. Dlatego stworzyłem to wyzwanie, które realizuje te trzy pomysły.

Twoim zadaniem, czytelnika i pasjonata golfa , jest stworzenie możliwie najkrótszego skryptu, który może działać w dwóch językach A i B, aby wygenerować quiny dla A i B. Gdy twój program działa w języku A, powinien wygenerować program, który jest quine w języku B, ale nie w języku A i odwrotnie. Języki A i B mogą być różnymi wersjami tego samego języka, pod warunkiem, że pamiętasz, że wygenerowane quiny powinny działać tylko w jednej z wersji.

Należy pamiętać, że standardowe luki należy uważać za zamknięte i dozwolone są tylko odpowiednie quinesy .

Powodzenia, najmniej znaków wygrywa!

CJam 0.6.6 dev / GolfScript, 15 14 12 bajtów

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

Dzięki @ jimmy23013 za grę w golfa z 2 bajtów!

Reszta do aktualizacji.

Weryfikacja

Ponieważ przesyłanie obejmuje znaczną spację, najlepiej porównać zrzuty szesnastkowe.

$ 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

Odbitki CJam "`0$~"0$~i końcowe podawanie linii. Wypróbuj online!

Wygenerowany program drukuje "`0$~"0$~z końcowym wysuwem wiersza w GolfScript ( Wypróbuj online! ), Ale bez wysuwu liniowego w CJam ( Wypróbuj online! ).

Jak działa metakina

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

Jak działa quine

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

W przeciwieństwie do GolfScript, CJam domyślnie nie drukuje końcowego przesuwu linii, więc nie jest to żadna quine w CJam.

GolfScript

Wydruki GolfScript "`0$~"0$~, bez spacji. Wypróbuj online!

Wygenerowany program drukuje "`0$~"0$~bez spacji w CJam ( Wypróbuj online! ), Ale GolfScript dołącza wiersz ( Wypróbuj online! ).

Jak działa metakina

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

Jak działa quine

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

W przeciwieństwie do CJam, GolfScript dołączy linię do zawartości stosu, więc nie jest to quine w GolfScript.

CJam / Rozszczepienie, 22 bajty

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

Wypróbuj w CJam. Wypróbuj w Fission.

W CJam wyświetla standardowy quine Fission :

'!+OR"

Wypróbuj quinę Fission.

W "Fission wypisuje bez-wariantową wersję standardowej Quine CJam:

{'_'~}_~

Spróbuj quine CJam.

Działa to również dla 22 bajtów (drukowanie tych samych quinesów):

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

Wyjaśnienie

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

Tak więc na końcu programu stos zawiera ciąg znaków "'!+OR"i znak ", które są domyślnie drukowane.

W rozszczepieniu przebieg programu rozpoczyna się Rod prawego atomu. '"tylko zmienia masy węgla ), 5i -są ignorowane z różnych powodów. Następnie atom wchodzi w tryb drukowania w "i drukuje {'_'~}_~. ;niszczy atom i kończy program.

Clojure / Common Lisp, 274 bajty

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

Dodano pewne spacje dla czytelności

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

Zasadniczo definiuje makro, które zwraca quine w Clojure. Clojure wymaga parametrów definicji makr podanych jako vector ( []), podczas gdy Common Lisp (na szczęście) po prostu to ignoruje. Następnie różnicujemy 2 języki, oceniając, '()który jest równy, nila zatem falsey w Common Lisp i jest truew Clojure. Następnie wykonujemy manipulacje ciągami przy użyciu Clojure, którego Common Lisp nawet nie próbuje ocenić, gdy przechodzi do innej ifgałęzi. Z drugiej strony Clojure próbuje sprawdzić, czy inna gałąź jest co najmniej poprawna przed wykonaniem, więc musiał evaltam użyć , aby zarówno był poprawny w Clojure, jak i wypisał poprawny ciąg w Common Lisp.

Uwaga: samo zwrócenie dwóch różnych ciągów znaków może być prawdopodobnie krótsze, ale wtedy nie będzie się różnić od wyzwań poliglota dotyczących wyświetlania różnych ciągów w różnych językach. ¯ \ _ (ツ) _ / ¯

Oryginalny źródłowy Clojure: https://ideone.com/SiQhPf

Wspólna oryginalna wersja źródłowa Lisp: https://ideone.com/huLcty

Wyjście Clojure: ((LAMBDA (S) (PRINT (LIST S (LIST 'QUOTE S)))) '(LAMBDA (S) (PRINT (LIST S (LIST 'QUOTE S)))))

Wspólne wyjście Lisp: ((fn [s] (print (list s (list (quote quote) s)))) (quote (fn [s] (print (list s (list (quote quote) s))))))

Wyjście Clojure uruchamiane we wspólnym Lisp: https://ideone.com/T1DF7H

Odwrotnie: https://ideone.com/Fezayq

Jelly / GolfScript, 18 16 bajtów

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

Weryfikacja

Testowanie wszystkich zaangażowanych programów z dokładnymi strumieniami bajtów można wykonać tylko lokalnie.

$ 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

Galareta

Ze stroną kodową Jelly program wygląda następująco.

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

To drukuje ( Wypróbuj online! )

":n`":n`

który jest quine w GolfScript ( Wypróbuj online! ), ale błąd parsera w Jelly ( Wypróbuj online! ).

GolfScript

W Latin-1 program wygląda następująco, z niedrukowalnym znakiem DEL pomiędzy }i þ.

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

To drukuje ( Wypróbuj online! )

ÿÌÌ

lub wizualizowane za pomocą strony kodowej Jelly,

”ṘṘ

który jest quine w Jelly ( Wypróbuj online! ), ale drukuje tylko wiersz w GolfScript ( Wypróbuj online! ).

JavaScript / C 278 bajtów

Przy oszałamiającym 278 bajtach:

//\
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));");}//*/

Quine C:

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

Quine 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 bajtów

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

Wypróbuj w Befunge | Wypróbuj w Fission

W Befunge tworzy to quine Fission :

'!+OR"

W Fission daje to Befine quine :

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

Python / Retina, 70 65 64 66 bajtów

Użyłem tej samej strategii, co poprzedniej wersji poliglota Python / Retina .

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

Spróbuj w Pythonie | Spróbuj w siatkówce

#jest komentarzem w Pythonie, więc po prostu drukuje w Rethine Quine. W Retina pierwszy etap (2 linie) nic nie robi, ponieważ #na wejściu nie będzie żadnych . Następny etap nie zastępuje niczego podstawą bazy Python. Trzeci etap zastępuje każdy średnik #print _%kawałkiem. Ostatni etap usuwa wszystko #.

Quine in Retina:

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

Quine w Pythonie:

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

Użyte quinesy można zobaczyć w tym wyzwaniu . Quine Retina jest błędem w Pythonie, a quine Python nie ma danych wyjściowych w Retinie.

Python 3 / Python 2, 62 bajty

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

Wypróbuj w Python 2 , Python 3 .

Na podstawie quine Python tutaj . Czynnikiem odróżniającym te dwie wersje jest to, co robią int(-1/2): w Pythonie 2 /jest dzielenie liczb całkowitych (zaokrąglanie w dół), z wynikiem -1; w Pythonie 3 /jest zmiennoprzecinkowe dzielenie ( -0.5), które zostaje intobcięte 0.

Budujemy sznurek _w trzech częściach. '_=%r;print(_%%_['i 'int(-1/2):])'zawsze są takie same. Interesująca część to '~'*-~int(-1/2):

• W Pythonie 2 -~int(-1/2)jest 0, a tylda nie jest dodawana do łańcucha;
• W Pythonie 3 -~int(-1/2)jest 1, a tylda jest dodawana do łańcucha.

Tak więc Python 2 generuje quine Python 3

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

a Python 3 generuje quine Python 2

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

W każdej wersji wyrażenie wewnątrz [ :]ocenia na 0, co powoduje, że plasterek zawiera cały ciąg, podczas gdy w niewłaściwym języku, na który ewaluuje -1, co powoduje, że plasterek zawiera tylko ostatni znak, obcinając wynik, więc nie jest to pełny quine.

Brain-Flak , brainfuck 4617 4009 bajtów

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

Wypróbuj online!

Wypróbuj online!

Wyjaśnienie jest w drodze Nadal gram w golfa