Ein Polyquin ist sowohl quin als auch polyglot. ¹ Sie müssen ein Quine schreiben, das in mindestens zwei verschiedenen Sprachen gültig ist. Dies ist Codegolf, daher gewinnt die kürzeste Antwort (in Bytes).

_{¹ Ich habe das erfunden. Oder besser gesagt, Geobits . Anscheinend war er auch nicht der erste .}

Regeln für Quines

Es werden nur echte Quines akzeptiert. Das heißt, Sie müssen den gesamten Quellcode wörtlich in STDOUT ausgeben, ohne :

• Lesen Sie Ihren Quellcode direkt oder indirekt.
• Verlassen Sie sich auf eine REPL-Umgebung, die einfach jeden Ausdruck, den Sie eingeben, auswertet und druckt.
• Verlassen Sie sich auf Sprachfunktionen, die in bestimmten Fällen nur die Quelle ausdrucken.
• Verwenden von Fehlermeldungen oder STDERR, um den Quine ganz oder teilweise zu schreiben. (Sie können Dinge in STDERR schreiben oder Warnungen / nicht schwerwiegende Fehler erzeugen, solange STDOUT eine gültige Quine ist und die Fehlermeldungen nicht Teil davon sind.)

Darüber hinaus Ihr Code muss eine Stringliteral enthalten.

Regeln für Mehrsprachige

Die beiden verwendeten Sprachen müssen sich deutlich unterscheiden. Bestimmtes:

• Es dürfen keine unterschiedlichen Versionen derselben Sprache sein (z. B. Python 2 oder Python 3).
• Es dürfen keine unterschiedlichen Dialekte derselben Sprache sein (zB Pascal vs. Delphi).
• Eine Sprache darf keine Teilmenge der anderen sein (zB C vs. C ++).

CJam / GolfScript, 34 Bytes

{"__X.0#@@?LL
;~"N}__X.0#@@?LL
;~

Die Byteanzahl enthält einen nachfolgenden Zeilenumbruch, da das Programm ohne diesen kein Quine wäre.

Während CJam und GolfScript in einigen Aspekten sehr ähnlich sind, gibt es viele Unterschiede. Um dies zu einem "ehrlichen" Polyquin zu machen, habe ich beschlossen, mich so weit wie möglich auf die Unterschiede zu verlassen . Mit Ausnahme der Block- und Zeichenfolgensyntax (die die Sprachen mit so vielen anderen teilen) erreicht kein Teil des Codes in beiden Sprachen genau das Gleiche.

Der Online-GolfScript-Interpreter weist einen Fehler auf. Dieses Programm funktioniert nur mit dem offiziellen Dolmetscher.

Beispiellauf

$ cat polyquine
{"__X.0#@@?LL
;~"N}__X.0#@@?LL
;~
$ md5sum polyquine <(cjam polyquine) <(golfscript polyquine)
e2f1f3cd68abbbceec58080513f98d9a  polyquine
e2f1f3cd68abbbceec58080513f98d9a  /dev/fd/63
e2f1f3cd68abbbceec58080513f98d9a  /dev/fd/62

Wie es funktioniert (CJam)

" Push that block.                                                                        ";

{"__X.0#@@?LL
;~"N}

" Push two copies of the block, 1 (computed as 1**0) and rotate the block copies on top.  ";

__X.0#@@

" If 1 is truthy (oh, the uncertainty), execute the first copy; else, execute the second.
  Evaluating the block pushes the string it contains; N pushes a linefeed.                ";

?

" Push two empty arrays.                                                                  ";

LL

" Discard one empty array and dump the second.                                            ";

;~

" (implicit) Print all items on the stack.                                                ";

Wie es funktioniert (GolfScript)

# Push that block.

{"__X.0#@@?LL
;~"N}

# Push a copy of the block; _ and X are noops, # initiates an inline comment.

__X.0#@@?LL

# Discard the 0 and execute the copy of the block.
# Evaluating the block pushes the string it contains; N is a noop.

;~

# (implicit) Print all items on the stack, followed by a linefeed.

CJam / GolfScript, 12 Bytes

{"0$~"N}0$~

Betrügerische Lösung, die die Sprachunterschiede so weit wie möglich vermeidet.

Probieren Sie es online aus:

• CJam
• GolfScript

Wie es funktioniert (CJam)

 "0$~"       " Push that string.                                                          ";
      N      " Push a linefeed.                                                           ";
{      }0$~  " Push a copy of the block and execute it.                                   ";
             " (implicit) Print the stack.                                                ";

Wie es funktioniert (GolfScript)

 "0$~"       # Push that string.
      N      # Undefined token (noop).
{      }0$~  # Push a copy of the block and execute it.
             # (implicit) Print the stack, followed by a linefeed.

C # / Java, 746 Bytes

Ich benutze die Eigenschaft, dass Zeichen in Java als identische Unicode-Sequenzen geschrieben werden können. Wenn wir eine AAnweisung für den C # -Compiler und eine BAnweisung für Java haben, können wir das folgende Codefragment verwenden:

//\u000A\u002F\u002A
A//\u002A\u002FB

Es wird auf folgende Weise mit C # "erkannt":

//\u000A\u002F\u002A
A//\u002A\u002FB

Und auf folgende Weise mit Java:

//
/*
A//*/B

Wegen \u000Aist Zeilenumbruch, \u002Fist /und \u002Aist *in Java.

Das endgültige polyglotte Quin ist also:

//\u000A\u002F\u002A
using System;//\u002A\u002F
class Program{public static void//\u000A\u002F\u002A
Main//\u002A\u002Fmain
(String[]z){String s="//@#'^using System;//'#^class Program{public static void//@#'^Main//'#main^(String[]z){String s=!$!,t=s;int[]a=new int[]{33,94,38,64,35,39,36};String[]b=new String[]{!&!!,!&n!,!&&!,!&@!,!&#!,!&'!,s};for(int i=0;i<7;i++)t=t.//@#'^Replace//'#replace^(!!+(char)a[i],b[i]);//@#'^Console.Write//'#System.out.printf^(t);}}",t=s;int[]a=new int[]{33,94,38,64,35,39,36};String[]b=new String[]{"\"","\n","\\","\\u000A","\\u002F","\\u002A",s};for(int i=0;i<7;i++)t=t.//\u000A\u002F\u002A
Replace//\u002A\u002Freplace
(""+(char)a[i],b[i]);//\u000A\u002F\u002A
Console.Write//\u002A\u002FSystem.out.printf
(t);}}

Die Größe ist jedoch aufgrund der Ausführlichkeit der Sprachen zu groß.

Auf ideone.com verfügbare Zusammenstellung: C # , Java .

Python 3 und JavaScript, 134 Byte

Hier ist mein (letzter?) Versuch:

a='eval(a.split(" ")[2%-4]),1//2# q=String.fromCharCode(39);console.log("a="+q+a+q+a.slice(-8)) print(a[-12:]%a) a=%r;eval(a)';eval(a)

Es kann wahrscheinlich ein bisschen mehr Golf gespielt werden, besonders wenn jemand eine bessere Möglichkeit kennt, einfache Anführungszeichen in JavaScript zu erhalten.

Eingekocht sieht das Programm so aus:

a='a long string';eval(a)

Die eval()Funktion wertet Ausdrücke in beiden Sprachen aus. So wird der lange String ausgeführt:

eval(a.split(" ")[2%-4]),1//2# ... the rest gets commented out

Dadurch wird die lange Zeichenfolge durch Leerzeichen geteilt und die durch indizierte Teilzeichenfolge ausgewertet 2%-4. JavaScript führt die dritte Teilzeichenfolge ( 2 % -4 == 2) und Python die vorletzte ( 2 % -4 == -2) aus, da sich ihre Modulo-Operatoren für Negative unterschiedlich verhalten.

Der Rest der Zeichenfolge wird in beiden Sprachen ignoriert. JavaScript stoppt am //, während Python es als Ganzzahldivision ansieht und am stoppt #.

Also druckt JavaScript den Quellcode hier auf die Konsole:

q=String.fromCharCode(39);console.log("a="+q+a+q+a.slice(-8))

Und Python hier:

print(a[-12:]%a)

Beide verwenden den letzten Teil des Strings, der eine Vorlage des Programms ist:

a=%r;eval(a)

Ruby / Perl / PHP, 52

$b='$b=%c%s%c;printf$b,39,$b,39;';printf$b,39,$b,39;

Wortwörtlich kopiert aus Christopher Durrs Perl quine.

Dies ist Missbrauchsregeln. Ruby und Perl sind definitiv nicht dieselbe Sprache, und Perl ist auch keine Teilmenge von Ruby (die meisten verknüpften Perl-Quines funktionieren beispielsweise in Ruby nicht). Aber Ruby wurde so entworfen, dass es Perl sehr ähnlich sieht, wenn Sie es wollen, und dies passiert häufig beim Golfen.

Bash / GolfScript, 73

.~0 () 
{ 
    declare "-f" @* ".~0" " () 
"+@n.;
    echo '.~0;'
}
.~0;

In den ersten drei Zeilen befindet sich jeweils ein Leerzeichen.

Bash / GolfScript, 78

alias :a~a.='eval "alias :a~a."\
;set [61 39]+a[39]+n"":a;echo ":a~a."'
:a~a.

PHP / Perl - 171

#<?PHP$s=1;$t="";
$a='%s<%cPHP$s=1;$t="";%c$a=%c%s%c;$t==$s?$t="#":$s;printf($a,$t,63,10,39,$a,39,10,63);%c#%c>';$t==$s?$t="#":$s;printf($a,$t,63,10,39,$a,39,10,63);
#?>

Laufen mit:

$ php quine.pl
$ perl quine.pl

Der phpCode wird tatsächlich ausgeführt (nicht nur selbst gedruckt).

Bash / Ruby, 104 82

"tee`#";puts <<a*2+'a'#`" -<<'a';echo a
"tee`#";puts <<a*2+'a'#`" -<<'a';echo a
a

Ältere Version:

"alias" "puts=f()(tee -;echo a);f"
puts <<a *2+"a"
"alias" "puts=f()(tee -;echo a);f"
puts <<a *2+"a"
a

Bash / Ruby, 128 ohne undefiniertes Verhalten

"alias" 'puts=f()(a=`cat`;echo "$a
$a
a");f'
puts <<'a' *2+"a"
"alias" 'puts=f()(a=`cat`;echo "$a
$a
a");f'
puts <<'a' *2+"a"
a

reticular / befunge-98, 28 bytes [nicht konkurrierend]

<@,+1!',k- ';';Oc'43'q@$;!0"

Versuchen Sie es mit einem Netz! Versuchen Sie befunge 98!

Alles, was zwischen ;s in befunge liegt, wird ignoriert und !springt ;für reticular in das Segment zwischen s. So sieht reticular:

<@,+1!',k- ';';Oc'43'q@$;!0"
<                             move left
                           "  capture string
                          0   push zero
                        ;!    skip `;` (end program)
                       $      drop zero
                     q@       reverse TOS
                 '43'         push 34 (")
                c             convert to char
               O              output all
              ;               end program

Befunge sieht:

<@,+1!',k- ';';Oc'43'q@$;!0"
<                            move left
                           " capture string
                         !0  push 1
              ;         ;    skip this
         - ';'               push 27
       ,k                    output top 27 chars
   +1!'                      push 34 (")
  ,                          output "
 @                           end program

Ruby / Mathematica, 225 Bytes

Hier ist mein eigenes sehr schlagbares Polyquin (das als Beispiel und Proof-of-Concept dient):

s="s=%p;puts s%%s;#Print[StringReplace[s,{(f=FromCharacterCode)@{37,112}->ToString@InputForm@s,f@{37,37}->f@37}]]&@1";puts s%s;#Print[StringReplace[s,{(f=FromCharacterCode)@{37,112}->ToString@InputForm@s,f@{37,37}->f@37}]]&@1

Der erste Teil basiert auf diesem Ruby Quine und ist im Grunde:

s="s=%p;puts s%%s;#MathematicaCode";puts s%s;#MathematicaCode

Die Stringzuordnung ist in Mathematica genau gleich. Das puts s%swird als ein Produkt von 4 Symbolen interpretiert: putsdie Zeichenfolge s, %(das letzte REPL Ergebnis oder Out[0]wenn es der erste Ausdruck , den Sie bewerten) und andere s. Das ist natürlich völlig bedeutungslos, aber Mathematica kümmert sich nicht darum und ;unterdrückt jede Ausgabe, so dass dies nur im Hintergrund verarbeitet wird. Dann #wird der Rest der Zeile zu einem Kommentar für Ruby, während Mathematica fortfährt.

Der größte Teil des Mathematica-Codes besteht darin, die Format-String-Verarbeitung von Ruby ohne Verwendung von String-Literalen zu simulieren. FromCharacterCode@{37,112}ist %pund FromCharacterCode@{37,112}ist %%. Ersteres wird durch die Zeichenfolge selbst ersetzt (wobei InputFormdie Anführungszeichen hinzugefügt werden), letzteres durch eine einzelne %. Das Ergebnis ist Printed. Der letzte Haken ist, wie man #vorne damit umgeht. Dies ist das Symbol von Mathematica für das erste Argument einer reinen (anonymen) Funktion. Also machen wir das alles zu einer reinen Funktion, indem wir sie anhängen &und sofort mit Argumenten aufrufen 1. Das Voranstellen eines 1zu einem Funktionsaufruf "multipliziert" das Ergebnis mit1, die Mathematica wieder schluckt, unabhängig davon, was die Funktion zurückgibt.

> <> und CJam, 165 Bytes

"~~~~~~~~~~~~~~~~~~~~~~~r00gol?!v93*0.Hi
'                               <       .1*5av!?log10oar~~~r
'"`{"`"\"_~e#.21 <.2+4*96;!?log10oa"}_~e#.21 <.2+4*96;!?log10oa

Für CJam beginnt das Programm mit einem mehrzeiligen Zeichenfolgenliteral. Dies wird mit `maskiert und verwendet dann das Standard-Quine, um den Quine-Code sowie einen nachfolgenden Kommentar zu drucken.

Bei> <> "startet der erste Befehl ein String-Literal, das die gesamte erste Zeile durchläuft und jedes Zeichen auf den Stapel schiebt. Danach werden die abschließenden Leerzeichen (die aufgrund des Auffüllens der Eingabe erstellt wurden) gelöscht, und der Stapel wird umgekehrt. Jedes Zeichen im Stapel (dh die gesamte erste Zeile) wird ausgegeben und dann in die zweite Zeile verschoben.

Die zweite Zeile macht im Wesentlichen dasselbe, nur dass sie in die entgegengesetzte Richtung zeigt, sodass Sie den Stapel nicht umkehren müssen. (Mache ich trotzdem, da ich die nachgestellten Leerzeichen löschen muss.)

Schließlich geht es weiter zur dritten Zeile. Der einzige große Unterschied besteht darin, dass Sie den CJam-Block überspringen müssen. Dies geschieht mit .Das einfache Anführungszeichen erfasst die gesamte Zeile (wieder rückwärts) und gibt sie dann aus.

C / PHP, 266 304 300 282 241 203 + 10 Bytes

//<?php
function main($a){printf($a="%c//<?php%cfunction main(%ca){printf(%ca=%c%s%c,13,10,36,36,34,%ca,34,36,10,10,10);}%c#if 0%cmain();%c#endif",13,10,36,36,34,$a,34,36,10,10,10);}
#if 0
main();
#endif

+10 Byte, da für das Kompilieren in C das GCC-Compiler-Flag erforderlich ist -Dfunction=.

Wie es funktioniert (in PHP):

• Der PHP-Interpreter druckt einfach alles vor dem <?phpals HTML. //ist kein Kommentar in HTML, daher wird er einfach gedruckt.
• mainwird als Funktion mit einer Variablen deklariert a.
• printfdruckt einen Wagenrücklauf (um den bereits gedruckten zu überschreiben //) und dann den Quellcode unter Verwendung einer Standard-C / PHP-Quining-Methode.
• #if 0 wird von PHP ignoriert.
• main($a)initialisiert eine leere Variable a. (Dient früher error_reporting(0)zum Ignorieren von Fehlern, die durch Aufrufen verursacht wurden. main())
• #endif wird auch von PHP ignoriert.

Wie es funktioniert (in C):

• //<?php ist ein einzeiliger Kommentar, wird also ignoriert.
• Das functionSchlüsselwort wird aufgrund des Befehlszeilen-Compiler-Arguments ignoriert -Dfunction=.
• GCC und Clang ist es egal, ob Variablen mit beginnen oder enthalten $. (Das hat den Tag gerettet.)
• printf druckt einen Wagenrücklauf (in diesem Fall nutzlos) und dann den Quellcode unter Verwendung einer Standard-C / PHP-Quining-Methode.
• #if 0ignoriert alles bis zum endif, damit PHP aufrufen kann main.
• #endif Beendet den Block "Ignoriere mich".

Wumpus / > <> / Befunge-98 28 Bytes

"]#34[~#28&o@,k+deg0 #o#!g00

Probieren Sie es in Wumpus! , Versuchen Sie es in> <>! , Versuchen Sie es in Befunge-98!

Wie es funktioniert:

Wumpus-Code:

  " Start string literal
    Bounce off end of line and come back
  " End string literal
   ] Push top of stack to bottom
    #34 Push double quote
       [~ Get bottom of stack and swap it with the double quote
         #28 Push 28
            &o@ Print the top 28 items on stack and terminate program

> <> Code:

  " Start string literal
    Wrap when it reaches the end of the line
  " End string literal
   ]# Clear stack and reflect
  " Wrapping string literal again, but backwards
                     g00 Get the character from cell 0 (")
                 #o#! Skip into the printing loop
                      Exit with an error

Befunge-98 Code:

  " Wrapping string literal
   ] Turn right
   ] Turn right again, going West
  " Wrapping string literal going West
                 !g00 Get double quote and invert it
              #o# Skip over the o instruction
           g0   Get double quote
        +de Push 27
     @,k    Print 27+1 items from the stack and terminate program.

05AB1E / 2sable, 14 Byte, nicht konkurrierend

0"D34çý"D34çý

Probieren Sie es online! (05AB1E)
Probieren Sie es online! (2sable)

2sable leitet sich von 05AB1E ab und ist ähnlich, weist jedoch große Unterschiede auf.

Hinterer Zeilenumbruch.

C / TCL, 337 Bytes

#define set char*f= 
#define F 
#define proc main(){ 
set F "#define set char*f= 
#define F 
#define proc main(){ 
set F %c%s%c; 
proc /* {} {} 
puts -nonewline %cformat %cF 34 %cF 34 91 36 36] 
set a {*/printf(f,34,f,34,91,36,36);} 
"; 
proc /* {} {} 
puts -nonewline [format $F 34 $F 34 91 36 36] 
set a {*/printf(f,34,f,34,91,36,36);} 

C / Vim 4.0, 1636 Bytes

Enthält Steuerzeichen.

map () {}/*
map g ;data0df"f"cf"
f"cf"
f"D2kyyP;g6k2dd4x5jA"JxA","JxA","jyyPkJxA"jok;g2kdd4xkJx3jdd
map ;g O"vdldd0i# 0# 1# 2# 3# 4# 5# #0lx2lx2lx2lx2lx2lx2lx:s/##/#/g
o:s//"/gk0y2lj02lp"addk@ao:s//\\/gk0ly2lj02lp"addk@ao:s///gk04ly2lj02lp05l"vp"addk@ao:s///gk05ly2lj02lp05l"vp"vp"addk@ao:s//
/gk06ly2lj02lp05l"vp"vp"vp"addk@ao:s//
/gk02ly2lj02lp05l"vp"addk@a
unmap ()

map ;data o*/ char*g[]={"map () {}/*#2map g ;data0df#0f#0cf#0#5#3f#0cf#0#5#3f#0D2kyyP;g6k2dd4x5jA#0#3JxA#0,#0#3JxA#0,#0#3jyyPkJxA#0#3jo#3k;g2kdd4xkJx3jdd#2map ;g O#4#4#4#4#3#0vdldd0i## 0## 1## 2## 3## 4## 5## ###30lx2lx2lx2lx2lx2lx2lx:s/####/##/g#5o:s//#0/g#3k0y2lj02lp#0addk@ao:s//#1#1/g#3k0ly2lj02lp#0addk@ao:s//#4#4#3/g#3k04ly2lj02lp05l#0vp#0addk@ao:s///g#3k05ly2lj02lp05l#0vp#0vp#0addk@ao:s//#4#4#5/g#3k06ly2lj02lp05l#0vp#0vp#0vp#0addk@ao:s//#4#4#5/g#3k02ly2lj02lp05l#0vp#0addk@a#2unmap ()#2#2map ;data o*/ char*g[]={","#A#0#a#0,#0#b#0,#0#c#0#C#2","}; /*#3#2#2#0*/  print(char*s){char*t=s,c,d;while(c=*t++)if(c==35){c=*t++;if(c==35)putchar(c);else if(c==48)putchar(34);else if(c==49)putchar(92);else if(c==50)printf(#0#1n#0);else if(c==51)putchar(27);else if(c==52)putchar(22);else if(c==53)putchar(13);else if(c>64&&c<91)print(g[c-65]);else printf(g[c-97]);}else putchar(c);}  main(){print(g[1]);}"}; /*

"*/  print(char*s){char*t=s,c,d;while(c=*t++)if(c==35){c=*t++;if(c==35)putchar(c);else if(c==48)putchar(34);else if(c==49)putchar(92);else if(c==50)printf("\n");else if(c==51)putchar(27);else if(c==52)putchar(22);else if(c==53)putchar(13);else if(c>64&&c<91)print(g[c-65]);else printf(g[c-97]);}else putchar(c);}  main(){print(g[1]);}

Ihr Vim muss das folgende Set haben:

set noai
set wm=0
set nosi
set tw=0
set nogdefault

C / Lisp, 555 Bytes

t(setq /*;*/){}main(){char q='\"',s='\\';char*a= 
"~%t(setq /*;*/){}main(){char q='~A';char*a= 
~S;char*b=/* 
)(setq a ~S) 
(setq */ ~S;printf(b,s,q,s,s,q,a,q,q,s,s,s,q,s,s,s,s,q,q,b,q/* 
)(format t /* a /* a */);}~%";char*b=/* 
)(setq a "\\\"',s='\\\\") 
(setq */ " 
t(setq /*;*/){}main(){char q='%c%c',s='%c%c';char*a= 
%c%s%c;char*b=/* 
)(setq a %c%c%c%c%c',s='%c%c%c%c%c) 
(setq */ %c%s%c;printf(b,s,q,s,s,q,a,q,q,s,s,s,q,s,s,s,s,q,q,b,q/* 
)(format t /* a /* a */);} 
";printf(b,s,q,s,s,q,a,q,q,s,s,s,q,s,s,s,s,q,q,b,q/* 
)(format t /* a /* a */);} 

Absichtlich leere erste Zeile.

Perl / Javascript (SpiderMonkey), 106 Bytes

$_='$q=+[]?h^O:unescape("%27");print("$_="+$q+$_+$q+";eval($_)"||(q($_),"=$q$_$q;",q(eval($_))))';eval($_)

Probieren Sie das Perl online!
Probieren Sie das JavaScript online!

Erläuterung

Die quine-Daten werden in $_beiden Sprachen gespeichert und dann evalbearbeitet, was in Perl so ziemlich Standard ist. Ich habe SpiderMonkey für TIO ausgewählt, da es eine printFunktion hat, diese kann jedoch leicht für + 20 Byte auf den Browser portiert werden ( eval("print=alert");am Anfang der $_Definition hinzufügen ).

Perl sieht die darin gespeicherten Daten $_und evals es wie gewohnt. Da +[]in Perl wahr 'ist, wird in $qüber das String-XOR von hund gespeichert O. Der letzte Trick ist der Aufruf, in printdem der erste Teil für JavaScript verwendet wird +, der in Perl alle Elemente als Zahlen behandelt und sich zu summiert 0. Dann verwenden wir den ||Operator, um das zurückzugeben, was wir tatsächlich wollen, (q($_),"=$q$_$q;",q(eval($_)))was äquivalent ist "\$_=$q$_$q;eval(\$_)".

In JavaScript wird +[]zurückgegeben 0, daher rufen wir unescape("%27")zum Speichern 'auf $q(existiert leider atobnicht in SpirderMonkey ...). printDa +es sich beim Aufruf von um den Verkettungsoperator in JavaScript handelt, erstellt der erste Block die gewünschte Ausgabe und der zweite Teil nach dem ||wird ignoriert.

Vielen Dank an Patrick Roberts Kommentar für den unescapeTrick!

Perl / JavaScript (Browser), 108 Byte

$_='eval("q=_=>_+``;printf=console.log");printf(q`$_=%s%s%s;eval($_)`,$q=+[]?h^O:atob("Jw"),$_,$q)';eval($_)

Probieren Sie das Perl online!

$_='eval("q=_=>_+``;printf=console.log");printf(q`$_=%s%s%s;eval($_)`,$q=+[]?h^O:atob("Jw"),$_,$q)';eval($_)

Erläuterung

Wir speichern die quine-Daten in $_beiden Sprachen und dann eval, was in Perl so ziemlich Standard ist.

Perl sieht die darin gespeicherten Daten $_und evals es wie gewohnt. Das evalInnere $_wird ausgeführt und kann nicht analysiert werden, aber da es ausgeführt wird eval, tritt kein Fehler auf. printfwird dann mit einem String in Anführungszeichen q()mit `als Trennzeichen aufgerufen, da nur die Verwendung dazu führen `würde, dass Befehle in der Shell ausgeführt werden, und wird dann für die erste Verwendung von $q, da +[]dies in Perl wahr 'ist, $qüber stringwise-XOR von hund gespeichert O.

In JavaScript richtet der evalBlock innerhalb $_eine Funktion ein q, returnderen Argument als Stringund als Aliase console.logfür gilt printf, da console.logZeichenfolgen wie printfin Perl formatiert werden . Wann printfwird +[]return genannt 0, also rufen wir atobzum Entschlüsseln 'und Speichern auf $q.

Perl 5 / Ruby / JavaScript (Node.js) / Bash / Python 2 / PHP , 1031 Byte

s=1//2;_=r'''<?#/.__id__;s=+0;#';read -d '' q<<'';s=\';Q='echo s=1//2\;_=r$s$s$s\<\?\#/.__id__\;s=+0\;#$s\;read -d $s$s q\<\<$s$s\;s=\\$s\;Q=$s$Q$s\;eval\ \$Q;echo $q';eval $Q
$_='eval("0"?0?"def strtr(s,f,t);s.tr(f,t) end;class String;def chr(n);self+n.chr end;end":"$u=strtr=(s,f,t)=>[...f].reduce((s,a,i)=>s.replace(RegExp(a,`g`),t[i]),s);printf=console.log;(S=String).prototype.chr=function(n){return this+S.fromCharCode(n)}":[]&&"sub strtr{eval q(q(X)=~y/X/X/r)=~s/X/shift/ger}");printf(strtr("%s<?#/.__id__;s=+0;#j;read -d jj q<<jj;s=zj;Q=jecho s=1//2z;_=rksksksz<z?z#/.__id__z;s=+0z;#ksz;read -d ksks qz<z<ksksz;s=zzksz;Q=kskQksz;evalz zkQ;echo kqj;eval kQwk_=j%sj;eval(k_);//;#jjj;f=jjjs=1//2;_=r%%s%%s%%s;f=%%s%%s%%s;q=_[18]*3;print f%%%%(q,_,q,q,f,q)jjj;q=_[18]*3;print f%%(q,_,q,q,f,q)%s","jkwz","".chr(39).chr(36).chr(10).chr(92).chr(92)),[]&&"s=1//2;_=r".chr(39).chr(39).chr(39),$_,$u?"":"".chr(10));';eval($_);//;#''';f='''s=1//2;_=r%s%s%s;f=%s%s%s;q=_[18]*3;print f%%(q,_,q,q,f,q)''';q=_[18]*3;print f%(q,_,q,q,f,q)

Überprüfen Sie es online!

Aufgrund meiner Aktualisierungen dieser Antwort dachte ich, ich würde versuchen, den Code zu optimieren, der eine andere Permutation ausgibt, aber am Ende Bash hinzufügte, wodurch ohnehin mehr Bytes hinzugefügt wurden. Dies ist zwar optimierter als mein erster Versuch (über 300 Bytes gespart), aber ich bin sicher, dass es noch weiter golfen werden kann.

Alternatives Perl 5 / Ruby / JavaScript (Node.js) / Bash / Python 2 / PHP , 1040 Byte

s=1//2;_=r'''<?#/.__id__;s=+0;#';read -d '' q<<'';s=\';Q='echo s=1//2\;_=r$s$s$s\<\?\#/.__id__\;s=+0\;#$s\;read -d $s$s q\<\<$s$s\;s=\\$s\;Q=$s$Q$s\;eval\ \$Q;echo $q';eval $Q
$_='$z=0?"$&".next+92 .chr+10 .chr: 0..a||eval("printf=console.log;unescape`$%27%5C%0Ak`");$q=$z[1]?$z[1]:h^O;printf("%s%s%s%s<?#/.__id__;s=+0;#%s;read -d %s%s q<<%s%s;s=%s%s;Q=%secho s=1//2%s;_=r%ss%ss%ss%s<%s?%s#/.__id__%s;s=+0%s;#%ss%s;read -d %ss%ss q%s<%s<%ss%ss%s;s=%s%s%ss%s;Q=%ss%sQ%ss%s;eval%s %s%sQ;echo %sq%s;eval %sQ%s%s_=%s%s%s;eval(%s_);//;#%s%s%s;f=%s%s%ss=1//2;_=r%%s%%s%%s;f=%%s%%s%%s;q=_[18]*3;print f%%%%(q,_,q,q,f,q)%s%s%s;q=_[18]*3;print f%%(q,_,q,q,f,q)%s",[]&&"s=1//2;_=r",$r=[]&&$q,$r,$r,$q,$q,$q,$q,$q,$b=$z[2]?$z[2]:chr(92),$q,$q,$b,$d=$z[0]?$z[0]:h^L,$d,$d,$b,$b,$b,$b,$b,$d,$b,$d,$d,$b,$b,$d,$d,$b,$b,$b,$d,$b,$d,$d,$d,$b,$b,$b,$d,$d,$q,$d,$n=$z[3]?$z[3]:chr(10),$d,$q,$_,$q,$d,$q,$q,$q,$q,$q,$q,$q,$q,$q,$z[4]?"":$n);';eval($_);//;#''';f='''s=1//2;_=r%s%s%s;f=%s%s%s;q=_[18]*3;print f%%(q,_,q,q,f,q)''';q=_[18]*3;print f%(q,_,q,q,f,q)

Überprüfen Sie es online!

Ein bisschen näher an meinem ursprünglichen Ansatz, aber die Wiederholung der Argumente für printfist immer noch verrückt. Wenn Sie stattdessen Positionsargumente verwenden, funktioniert dies nur in Chrome und es ist schwierig, auch in PHP zu arbeiten, da das $sIn %1$sinterpoliert ist, aber viele Bytes einsparen könnte, wenn Sie möglicherweise eine Kombination der beiden Ansätze verwenden ...

C / dc, 152 Bytes

z1d//[[z1d//]P91PP93P[dx]Pq 
;main(){char*a="z1d//[[z1d//]P91PP93P[dx]Pq%c;main(){char*a=%c%s%c;printf(a,10,34,a,34);}//]dx";printf(a,10,34,a,34);}//]dx

Kommentare nutzen, ja!

Perl 5 / Ruby / PHP / JavaScript (Browser), 153 Byte

$_='$z=0?"$&".next: 0..a||eval("printf=console.log;atob`JCc`");printf("%s_=%s%s%s;eval(%s_);",$d=$z[0]?$z[0]:h^L,$q=$z[1]?$z[1]:h^O,$_,$q,$d);';eval($_);

Probieren Sie das Perl online!
Probieren Sie den Ruby online aus!
Probieren Sie das PHP online!

$_='$z=0?"$&".next: 0..a||eval("printf=console.log;atob`JCc`");printf("%s_=%s%s%s;eval(%s_);",$d=$z[0]?$z[0]:h^L,$q=$z[1]?$z[1]:h^O,$_,$q,$d);';eval($_);