Une polyquine est à la fois quine et polyglotte. ¹ Vous devez écrire un quine qui est valide dans au moins deux langues différentes. C'est le code de golf, donc la réponse la plus courte (en octets) gagne.

_{¹ J'ai inventé ça. Ou plutôt, Geobits l'a fait . Apparemment, il n'était pas le premier non plus .}

Règles pour les quines

Seuls les vrais quines sont acceptés. Autrement dit, vous devez imprimer le code source entier intégralement sur STDOUT, sans :

• lire votre code source, directement ou indirectement.
• en s’appuyant sur un environnement REPL qui évalue et imprime simplement chaque expression que vous lui donnez.
• en s'appuyant sur des fonctionnalités linguistiques qui ne font qu'imprimer la source dans certains cas.
• en utilisant des messages d'erreur ou STDERR pour écrire tout ou partie de la quine. (Vous pouvez écrire des choses dans STDERR ou produire des avertissements / des erreurs non fatales tant que STDOUT est une requête valide et que les messages d'erreur n'en font pas partie.)

De plus, votre code doit contenir un littéral de chaîne.

Règles pour les polyglottes

Les deux langues utilisées doivent être nettement différentes. En particulier:

• Il ne doit pas s'agir de versions différentes du même langage (par exemple, Python 2 ou Python 3).
• Ils ne doivent pas être différents dialectes de la même langue (par exemple, Pascal vs Delphi).
• Un langage peut ne pas être un sous-ensemble de l’autre (par exemple, C vs. C ++).

CJam / GolfScript, 34 octets

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

Le nombre d'octets contient un saut de ligne de fin, car le programme ne serait pas un quine sans lui.

Bien que CJam et GolfScript soient très similaires à certains égards, il existe de nombreuses différences. Pour en faire une polyquine "honnête", j'ai décidé de m'appuyer autant que possible sur les différences . À l'exception de la syntaxe de bloc et de chaîne (que les langages partagent avec tant d'autres), aucune partie du code n'obtient exactement la même chose dans les deux langages.

L’interprète GolfScript en ligne a un bogue; ce programme fonctionne uniquement avec l'interprète officiel.

Exemple d'exécution

$ 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

Comment ça marche (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.                                                ";

Comment ça marche (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 octets

{"0$~"N}0$~

Solution astucieuse qui évite autant que possible les différences entre les langues.

Essayez-le en ligne:

• CJam
• GolfScript

Comment ça marche (CJam)

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

Comment ça marche (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 octets

J'utilise la propriété que les caractères en Java peuvent être écrits en tant que séquences Unicode identiques. Si nous avonsA instructions pour le compilateur C # et des Binstructions pour Java, nous pouvons utiliser le fragment de code suivant:

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

Il sera "reconnu" de la manière suivante avec C #:

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

Et de la manière suivante en Java:

//
/*
A//*/B

En raison de la \u000Arupture de ligne, \u002Fest/ et \u002Aest *en Java.

Ainsi, la dernière quille polyglotte est:

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

Cependant, la taille est trop énorme à cause de la verbosité des langues.

Compilation disponible sur ideone.com: C # , Java .

Python 3 et JavaScript, 134 octets

Voici ma (dernière?) Tentative:

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)

On peut probablement jouer un peu plus au golf, surtout si quelqu'un connaît un meilleur moyen d'obtenir des guillemets simples en JavaScript.

En résumé, le programme ressemble à ceci:

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

La eval()fonction évaluera les expressions dans les deux langues. Donc, la longue chaîne est exécutée:

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

Cela divise la chaîne longue en espaces et évalue la sous-chaîne indexée par 2%-4. JavaScript exécutera la troisième sous-chaîne ( 2 % -4 == 2) et Python l'avant-dernière ( 2 % -4 == -2), car leurs opérateurs modulo se comportent différemment pour les négatifs.

Le reste de la chaîne est ignoré dans les deux langues. JavaScript s’arrête au début //, alors que Python le voit comme une division entière et s’arrête au début #.

Donc, JavaScript imprime le code source sur la console ici:

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

Et Python ici:

print(a[-12:]%a)

Les deux utilisent la dernière partie de la chaîne, qui est un modèle du programme:

a=%r;eval(a)

Ruby / Perl / PHP, 52

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

Copié textuellement de Perl quine de Christopher Durr .

C'est abus de règles. Ruby et Perl ne sont certainement pas la même langue et Perl n'est pas non plus un sous-ensemble de Ruby (la plupart des quines Perl liées ne fonctionnent pas dans Ruby, par exemple). Mais Ruby a été conçu pour pouvoir ressembler beaucoup à Perl si vous le souhaitez, et cela se produit souvent lorsque vous jouez au golf.

Bash / GolfScript, 73

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

Il y a un espace de fin sur chacune des 3 premières lignes.

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

Courir avec:

$ php quine.pl
$ perl quine.pl

Le phpcode est en cours d'exécution (pas seulement en train de s'imprimer).

Bash / Ruby, 104 82

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

Ancienne 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 sans comportement indéfini

"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

réticulaire / befunge-98, 28 octets [non compétitif]

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

Essayez réticulaire! Essayez befunge 98!

Tout ce qui est entre ;s et befunge est ignoré et !saute dans le segment entre ;s pour réticulaire. Ainsi, réticulaire voit:

<@,+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 voit:

<@,+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 octets

Voici ma propre polyquine très palpable (qui sert d'exemple et de preuve de concept):

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

La première partie est basée sur cette quine Ruby et est essentiellement:

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

L'affectation de chaîne est exactement la même dans Mathematica. Le puts s%sest interprété comme un produit de 4 symboles:, putsla chaîne s, %(le dernier résultat REPL ou Out[0]s'il s'agit de la première expression évaluée) et un autre s. Bien entendu, cela n'a aucun sens, mais Mathematica s'en fiche et; supprime aucune sortie. Elle est donc traitée en mode silencieux. Ensuite, #le reste de la ligne devient un commentaire pour Ruby pendant que Mathematica continue.

En ce qui concerne le code Mathematica, la plus grande partie consiste à simuler le traitement des chaînes de format de Ruby sans utiliser de littéraux de chaîne. FromCharacterCode@{37,112}est %pet FromCharacterCode@{37,112}est %%. Le premier est remplacé par la chaîne elle-même (oùInputForm les citations sont ajoutées), le second par un simple %. Le résultat est Printed. La dernière difficulté est de savoir comment gérer cela #à l’avant. C'est le symbole de Mathematica pour le premier argument d'une fonction pure (anonyme). Donc ce que nous faisons est que nous faisons tout cela une pure fonction en annexant &et immédiatement appeler la fonction avec l' argument 1. Le préfixe 1d'un appel de fonction "multiplie" le résultat avec1, que Mathematica avale à nouveau, quel que soit le type d’objet renvoyé par la fonction.

> <> et CJam, 165 octets

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

Pour CJam, le programme commence par un littéral de chaîne multiligne. Ceci est échappé avec` , puis il utilise le quine standard pour imprimer le code quine, ainsi qu'un commentaire de fin.

Pour> <>, le premier " commence un littéral de chaîne qui traverse toute la première ligne, poussant chaque caractère vers la pile. Après cela, les espaces de fin (créés en raison de l'entrée en cours de remplissage) sont supprimés, puis la pile est inversée. Chaque caractère de la pile (c’est-à-dire la première ligne entière) est sorti, puis il descend à la deuxième ligne.

La deuxième ligne fait essentiellement la même chose, sauf que c'est dans la direction opposée, vous n'avez donc pas besoin d'inverser la pile. (Je fais quand même, parce que je dois supprimer les espaces de fin.)

Enfin, il passe à la troisième ligne. La seule différence majeure est que vous devez ignorer le bloc CJam, qui est effectué à l'aide de .la citation unique qui capture la ligne entière (encore une fois, à l'envers), puis la sortie.

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

//<?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 octets car la compilation en C nécessite l'indicateur de compilation GCC -Dfunction= .

Comment ça marche (en PHP):

• L'interprète PHP affiche simplement tout ce qui précède le <?phpformat HTML. //n'est pas un commentaire en HTML, il est donc simplement imprimé.
• mainest déclaré comme une fonction avec une variable a.
• printf imprime un retour chariot (pour remplacer le texte déjà imprimé // ), puis le code source, en utilisant une méthode de quining C / PHP standard.
• #if 0 est ignoré par PHP.
• main($a)initialise une variable vide a. (Auparavant utilisé error_reporting(0)pour ignorer les erreurs causées par un appel main())
• #endif est également ignoré par PHP.

Comment ça marche (en C):

• //<?php est un commentaire d'une seule ligne, il est donc ignoré.
• Le functionmot clé est ignoré en raison de l'argument du compilateur de ligne de commande -Dfunction=.
• GCC et Clang ne s'inquiètent pas de savoir si les variables commencent ou contiennent $. (Cela a sauvé la journée.)
• printf affiche un retour chariot (inutile dans ce cas), puis le code source, en utilisant une méthode de quining C / PHP standard.
• #if 0ignore tout jusqu'à ce que endifPHP puisse appeler main.
• #endif termine le bloc "ignore me".

Wumpus / > <> / Befunge-98 28 octets

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

Essayez-le dans Wumpus! , Essayez - le dans> <>! , Essayez - le dans Befunge-98!

Comment ça marche:

Code Wumpus:

  " 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

Code Befunge-98:

  " 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 octets, non en concurrence

0"D34çý"D34çý

Essayez-le en ligne! (05AB1E)
Essayez-le en ligne! (2sable)

2sable est dérivé de 05AB1E et est similaire, mais présente des différences majeures.

Retour à la ligne.

C / TCL, 337 octets

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

Contient des caractères de contrôle.

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]);}

Votre Vim doit avoir le set suivant:

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

C / Lisp, 555 octets

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

Intentionnellement vide, première ligne.

Perl / Javascript (SpiderMonkey), 106 octets

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

Essayez le Perl en ligne!
Essayez le JavaScript en ligne!

Explication

Les données quine sont stockées dans les $_deux langues, puis evaled, ce qui est à peu près la procédure standard en Perl. J'ai choisi SpiderMonkey sur TIO car il a une printfonction, mais cela pourrait facilement être porté au navigateur pendant + 20 octets (ajouter eval("print=alert");au début de la $_définition).

Perl voit les données stockées dans $_et evalest comme d’habitude. Since +[]est une vérité en Perl, 'est stocké dans $qvia stringwise-XOR de het O. La dernière astuce consiste à appeler printoù la première partie de JavaScript utilise +, qui, dans Perl, traite tous les éléments comme des nombres et leur ajoute 0, puis nous utilisons l' ||opérateur pour renvoyer ce que nous voulons réellement.(q($_),"=$q$_$q;",q(eval($_))) ce qui est équivalent "\$_=$q$_$q;eval(\$_)".

En JavaScript, les +[]retours 0, nous appelons donc unescape("%27")pour stocker 'dans $q(malheureusement, atobn'existe pas dans SpirderMonkey ...). Dans l'appel à print, puisqu'il +s'agit de l'opérateur de concaténation en JavaScript, le premier bloc construit la sortie souhaitée et la deuxième partie après ||est ignorée.

Merci à Patrick Roberts pour le unescapetour!

Perl / JavaScript (navigateur), 108 octets

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

Essayez le Perl en ligne!

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

Explication

Nous stockons les données quine $_dans les deux langues, puis evalil s’agit là d’une procédure à peu près standard en Perl.

Perl voit les données stockées dans $_et evalest comme d’habitude. Le evalinside $_est exécuté et ne parvient pas à analyser, mais comme il ne le evalfait pas, il ne commet pas d'erreur. printfest ensuite appelé, avec une seule chaîne entre guillemets q(), avec `comme délimiteur, car l’utilisation `de commandes aurait pour résultat l’exécution de commandes dans un shell, puis pour la première utilisation de $q, puisque +[]vérité est en Perl, elle 'est stockée $qvia stringwise-XOR deh et O.

En JavaScript, le evalbloc dans $_établit une fonction q, qui returnest son argument comme Stringet alias console.logpour printf, étant donné que la console.logchaîne de formats comme printfen Perl. Quand printfest appelé +[]retourne 0, alors nous appelons atobpour décoder 'et stocker dans $q.

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

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)

Vérifiez-le en ligne!

Sur la base de mes mises à jour de cette réponse , je pensais que j'essaierais d’optimiser le code qui imprime une permutation différente, mais j’ai fini par l’ajouter à Bash, ce qui ajoute de toute façon une charge supplémentaire. Bien que cela soit plus optimisé que ma première tentative (enregistré plus de 300 octets), je suis sûr que cela peut encore être joué.

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

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)

Vérifiez-le en ligne!

Un peu plus près de mon approche initiale, mais la répétition des arguments pour printfest toujours fou. En utilisant des arguments positionnels, cela ne fonctionne que dans Chrome et il est difficile de travailler en PHP également car l’ $sen %1$s-dedans est interpolé, mais pourrait économiser beaucoup d’octets, en combinant peut-être deux approches ...

C / dc, 152 octets

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

Profitant des commentaires, oui!

Perl 5 / Ruby / PHP / JavaScript (navigateur), 153 octets

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

Essayez le Perl en ligne!
Essayez le Ruby en ligne!
Essayez le PHP en ligne!

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