In meiner Zeit bei PPCG habe ich festgestellt, dass Quine-Probleme und Polyglot-Probleme sehr beliebt sind. Auch Meta-Lösungen für Probleme, dh Skripte, die ein Programm generieren, das die Lösung für ein Problem darstellt, werden von der Community häufig positiv bewertet. Deshalb habe ich diese Herausforderung geschaffen, die diese drei Ideen umsetzt.

Ihre Aufgabe, Leser und Code-Golf- Enthusiast, ist es dann, so kurz wie möglich ein Skript zu erstellen, das in zwei Sprachen A und B ausgeführt werden kann, um Quines für A und B zu generieren. Wenn Ihr Programm in Sprache A ausgeführt wird, sollte es eine generieren Programm, das eine Quine in Sprache B ist, aber nicht in Sprache A und umgekehrt. Die Sprachen A und B können unterschiedliche Versionen derselben Sprache sein, vorausgesetzt, dass die generierten Quines nur in einer der Versionen funktionieren sollten.

Beachten Sie, dass die Standardlücken als geschlossen betrachtet werden sollten und nur einwandfreie Quines zulässig sind.

Viel Glück, die wenigsten Charaktere gewinnen!

CJam 0.6.6 dev / GolfScript, 15 14 12 Bytes

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

Danke an @ jimmy23013 für das Golfen mit 2 Bytes!

Ruhe, um aktualisiert zu werden.

Nachprüfung

Da die Übermittlung signifikante Leerzeichen enthält, ist es am besten, Hexdumps zu vergleichen.

$ 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-Ausdrucke "`0$~"0$~und ein Zeilenvorschub am Ende. Probieren Sie es online!

Das generierte Programm druckt "`0$~"0$~mit dem nachfolgenden Zeilenvorschub in GolfScript ( Online testen ! ), Jedoch ohne den Zeilenvorschub in CJam ( Online testen ! ).

Wie das Metaquin funktioniert

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

Wie das Quine funktioniert

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

Im Gegensatz zu GolfScript druckt CJam standardmäßig keinen abschließenden Zeilenumbruch, daher ist dies in CJam kein Quine.

GolfScript

GolfScript druckt "`0$~"0$~ohne Leerzeichen. Probieren Sie es online!

Das generierte Programm druckt "`0$~"0$~ohne Leerzeichen in CJam ( Online testen ! ), Aber GolfScript fügt einen Zeilenvorschub an ( Online testen ! ).

Wie das Metaquin funktioniert

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

Wie das Quine funktioniert

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

Im Gegensatz zu CJam hängt GolfScript einen Zeilenvorschub an den Inhalt des Stapels an, sodass dies in GolfScript kein Quine ist.

CJam / Fission, 22 Bytes

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

Probieren Sie es in CJam. Probieren Sie es in Fission.

In CJam wird die Standard-Fission-Quine gedruckt :

'!+OR"

Probieren Sie die Fission Quine.

In Fission wird eine "-lose Variante des Standard-CJam-Quine ausgegeben:

{'_'~}_~

Probieren Sie die CJam Quine.

Dies funktioniert auch für 22 Bytes (Drucken der gleichen Quines):

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

Erläuterung

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

Am Ende des Programms enthält der Stapel die Zeichenfolge "'!+OR"und das Zeichen ", die beide implizit gedruckt werden.

In Fission beginnt der Programmablauf Rmit einem rechts stehenden Atom. '"nur ändert sich die Atome Masse ), 5und -werden aus verschiedenen Gründen ignoriert. Dann wechselt das Atom in den Druckmodus "und druckt {'_'~}_~. ;zerstört das Atom und beendet das Programm.

Clojure / Common Lisp, 274 Bytes

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

Einige Leerzeichen zur besseren Lesbarkeit hinzugefügt

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

Definiert grundsätzlich ein Makro, das in Clojure ein Quine zurückgibt. Clojure benötigt Parameter für die Makrodefinition, die als vector ( []) angegeben werden, während Common Lisp (zum Glück) diese nur ignoriert. Danach unterscheiden wir 2 Sprachen, indem wir auswerten, '()was nilin Common Lisp und truein Clojure gleich und somit falsch ist . Dann führen wir String-Manipulationen mit Clojure durch, das Common Lisp nicht einmal auszuwerten versucht, während es in einem anderen ifZweig läuft . Auf der anderen Seite versucht Clojure vor der Ausführung zu überprüfen, ob ein anderer Zweig mindestens korrekt ist. Daher musste er evaldort verwendet werden, um in Clojure korrekt zu sein und die richtige Zeichenfolge in Common Lisp auszugeben.

Hinweis: Wenn Sie nur zwei verschiedene Zeichenfolgen zurückgeben, ist dies wahrscheinlich kürzer, unterscheidet sich jedoch nicht von einer mehrsprachigen Herausforderung bei der Ausgabe verschiedener Zeichenfolgen in verschiedenen Sprachen. ¯ \ _ (ツ) _ / ¯

Führen Sie Clojure Original Source aus: https://ideone.com/SiQhPf

Gemeinsame Lisp-Originalquelle: https://ideone.com/huLcty

Clojure-Ausgabe: ((LAMBDA (S) (PRINT (LIST S (LIST 'QUOTE S)))) '(LAMBDA (S) (PRINT (LIST S (LIST 'QUOTE S)))))

Gemeinsame Lisp-Ausgabe: ((fn [s] (print (list s (list (quote quote) s)))) (quote (fn [s] (print (list s (list (quote quote) s))))))

Clojure-Ausgabe wird in Common Lisp ausgeführt: https://ideone.com/T1DF7H

Umgekehrt: https://ideone.com/Fezayq

Jelly / GolfScript, 18 bis 16 Bytes

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

Nachprüfung

Das Testen aller beteiligten Programme mit den genauen Byteströmen ist nur lokal möglich.

$ 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

Gelee

Mit Jellys Codepage sieht das Programm folgendermaßen aus.

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

Diese Abzüge ( Online ausprobieren! )

":n`":n`

Das ist eine Quine in GolfScript ( Online testen ! ), aber ein Parser-Fehler in Jelly ( Online testen ! ).

GolfScript

In Latin-1 sieht das Programm wie folgt aus, mit einem nicht druckbaren DEL-Zeichen zwischen }und þ.

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

Diese Abzüge ( Online ausprobieren! )

ÿÌÌ

oder, visualisiert mit Jellys Codepage,

”ṘṘ

Dies ist eine Quine in Jelly ( Online testen ! ), druckt jedoch nur einen Zeilenvorschub in GolfScript ( Online testen ! ).

JavaScript / C 278 Bytes

Bei atemberaubenden 278 Bytes:

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

Die C-Quine:

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

Die JavaScript-Quine:

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 Bytes

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

Probieren Sie es in Befunge | Probieren Sie es in Fission

In Befunge entsteht die Fission quine :

'!+OR"

In Fission ergibt dies die Befunge quine :

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

Python / Retina, 70 65 64 66 Bytes

Ich habe die gleiche Strategie verwendet, die ich in meinem vorherigen Python / Retina-Polyglot verwendet habe .

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

Versuchen Sie es in Python | Versuchen Sie es in Retina

#ist ein Kommentar in Python, der einfach die Retina quine in Python ausgibt. In Retina macht die erste Stufe (2 Zeilen) nichts, da #in der Eingabe kein gefunden wird. Die nächste Stufe ersetzt nichts mit der Grundlage der Python-Quine. Die dritte Stufe ersetzt jedes Semikolon durch das #print _%Stück. Die letzte Stufe entfernt alles #.

Quine in der Retina:

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

Quine in Python:

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

Die verwendeten Quines können in dieser Herausforderung gesehen werden . Die Retina-Quine ist ein Fehler in Python, und die Python-Quine hat keine Ausgabe in Retina.

Python 3 / Python 2, 62 Bytes

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

Probieren Sie es in Python 2 , Python 3 .

Basierend auf dem Python Quine hier . Der Unterscheidungsfaktor zwischen den beiden Versionen ist, was sie tun int(-1/2): In Python 2 /ist Integer Division (Abrunden) mit einem Ergebnis von -1; in Python 3 /ist Gleitkommadivision ( -0.5), die auf intabgeschnitten wird 0.

Wir bauen eine Saite _in drei Teilen. '_=%r;print(_%%_['und 'int(-1/2):])'sind immer gleich. Der interessante Teil ist '~'*-~int(-1/2):

• In Python 2 -~int(-1/2)ist 0und die Tilde wird der Zeichenfolge nicht hinzugefügt.
• In Python 3 -~int(-1/2)ist 1und die Tilde wird der Zeichenfolge hinzugefügt.

Somit gibt Python 2 die Python 3-Quine aus

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

und Python 3 gibt die Python 2-Quine aus

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

In jeder Version wird der Ausdruck im Inneren zu [ :]ausgewertet 0, wodurch das Segment die gesamte Zeichenfolge enthält, während das Segment in der falschen Sprache -1nur das letzte Zeichen enthält und die Ausgabe abschneidet, sodass es kein vollständiges Quine ist.

Brain-Flak , Brainfuck 4617 4009 Bytes

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

Probieren Sie es online!

Probieren Sie es online!

Erklärung ist auf dem Weg Ich spiele immer noch Golf