Uma poliquina é tanto quine quanto poliglota. ¹ Você deve escrever um quine válido em pelo menos dois idiomas diferentes. Isso é código de golfe, então a resposta mais curta (em bytes) vence.

_{¹ Eu inventei isso. Ou melhor, Geobits fez . Aparentemente, ele também não foi o primeiro .}

Regras para Quines

Somente quines verdadeiros são aceitos. Ou seja, você precisa imprimir todo o código fonte literalmente para STDOUT, sem :

• lendo seu código fonte, direta ou indiretamente.
• confiando em um ambiente REPL que simplesmente avalia e imprime todas as expressões que você alimenta.
• confiando em recursos de idioma que apenas imprimem a fonte em certos casos.
• usando mensagens de erro ou STDERR para escrever a totalidade ou parte da solução. (Você pode escrever coisas para STDERR ou produzir avisos / erros não fatais, desde que STDOUT seja uma solução válida e as mensagens de erro não façam parte dela.)

Além disso, seu código deve conter uma string literal.

Regras para poliglotas

Os dois idiomas usados ​​devem ser distintamente diferentes. Em particular:

• Eles não devem ter versões diferentes da mesma linguagem (por exemplo, Python 2 vs. Python 3).
• Eles não devem ter dialetos diferentes do mesmo idioma (por exemplo, Pascal vs. Delphi).
• Um idioma pode não ser um subconjunto do outro (por exemplo, C vs. C ++).

CJam / GolfScript, 34 bytes

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

A contagem de bytes contém um avanço de linha à direita, pois o programa não seria uma solução sem ele.

Enquanto CJam e GolfScript são muito semelhantes em alguns aspectos, existem muitas diferenças. Para fazer disso uma poliquina "honesta", decidi confiar nas diferenças o máximo possível. Exceto pela sintaxe de bloco e string (que os idiomas compartilham com tantos outros), nenhuma parte do código alcança exatamente o mesmo nos dois idiomas.

O intérprete online do GolfScript tem um erro; este programa funciona apenas com o intérprete oficial.

Exemplo de execução

$ 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

Como funciona (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.                                                ";

Como funciona (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$~

Solução barata que evita as diferenças dos idiomas o máximo possível.

Experimente online:

• CJam
• GolfScript

Como funciona (CJam)

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

Como funciona (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

Eu uso a propriedade que caracteres em Java podem ser gravados como seqüências unicode idênticas. Se tivermos Ainstruções para o compilador C # e Binstruções para Java, podemos usar o seguinte fragmento de código:

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

Será "reconhecido" da seguinte maneira com C #:

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

E da seguinte maneira pelo Java:

//
/*
A//*/B

Por causa da \u000Aquebra de linha, \u002Fé /e \u002Aestá *em Java.

Portanto, a poliglota-quina final é:

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

No entanto, o tamanho é muito grande devido à verbosidade dos idiomas.

Compilação disponível em ideone.com: C # , Java .

Python 3 e JavaScript, 134 bytes

Aqui está minha tentativa (final?):

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)

Provavelmente, pode ser jogado um pouco mais, especialmente se alguém souber uma maneira melhor de obter aspas simples em JavaScript.

Em resumo, o programa fica assim:

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

A eval()função avaliará expressões nos dois idiomas. Portanto, a cadeia longa é executada:

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

Isso divide a cadeia longa por espaços e avalia a substring indexada por 2%-4. O JavaScript executará a terceira substring ( 2 % -4 == 2) e o Python a segunda ( 2 % -4 == -2), porque seus operadores de módulo se comportam de maneira diferente para negativos.

O restante da string é ignorado nos dois idiomas. O JavaScript para no //, enquanto o Python o vê como divisão inteira e no #.

Portanto, o JavaScript imprime o código-fonte no console aqui:

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

E Python aqui:

print(a[-12:]%a)

Ambos fazem uso da parte final da string, que é um modelo do programa:

a=%r;eval(a)

Ruby / Perl / PHP, 52

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

Copiado literalmente do Perl quine de Christopher Durr .

Isso é abuso de regras. Definitivamente, Ruby e Perl não são a mesma linguagem, nem o Perl é um subconjunto de Ruby (a maioria dos arquivos Perl vinculados não funciona em Ruby, por exemplo). Mas Ruby foi projetado para ser parecido com o Perl, se você quiser, e isso acontece muito no golfe.

Bash / GolfScript, 73

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

Há um espaço à direita em cada uma das 3 primeiras linhas.

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

Correr com:

$ php quine.pl
$ perl quine.pl

O phpcódigo está realmente em execução (não apenas imprimindo em si).

Bash / Ruby, 104 82

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

Versão antiga:

"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 sem comportamento indefinido

"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 [não-competitivo]

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

Tente reticular! Tente antes do 98!

Qualquer coisa entre ;s em befunge é ignorada e !pula para o segmento entre ;s para reticular. Assim, reticular vê:

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

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

Aqui está minha própria poliquina muito imbatível (que serve como exemplo e prova de conceito):

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

A primeira parte é baseada nesta ruby ​​quine e é basicamente:

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

A atribuição de string é exatamente a mesma no Mathematica. O puts s%sé interpretado como um produto de 4 símbolos: puts, a corda s, %(o último resultado REPL ou Out[0]se é a primeira expressão a avaliar) e outro s. Naturalmente, isso é completamente sem sentido, mas o Mathematica não se importa e ;suprime nenhuma saída, então isso é processado silenciosamente. Em seguida, #torna o restante da linha um comentário para Ruby enquanto o Mathematica continua.

Quanto ao código do Mathematica, a maior parte dele, é simular o processamento de strings no formato Ruby sem usar literais de strings. FromCharacterCode@{37,112}é %pe FromCharacterCode@{37,112}é %%. O primeiro é substituído pela própria string (onde InputFormadiciona as aspas) e o último por um único %. O resultado é Printed. O problema final é como lidar com isso #na frente. Este é o símbolo do Mathematica para o primeiro argumento de uma função pura (anônima). Então, o que fazemos é transformar tudo isso em uma função pura, acrescentando &e chamando a função imediatamente com argumento 1. Anexar a 1a uma chamada de função "multiplica" o resultado com1, que o Mathematica novamente engole, independentemente do tipo de coisa retornada pela função.

> <> e CJam, 165 bytes

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

Para CJam, o programa inicia com uma literal de seqüência de caracteres de várias linhas. Isso é ignorado e `, em seguida, ele usa o quine padrão para imprimir o código do quine, além de um comentário à direita.

Para> <>, o primeiro "inicia uma literal de seqüência de caracteres que percorre toda a primeira linha, empurrando todos os caracteres para a pilha. Depois disso, os espaços finais (criados devido ao preenchimento da entrada) são excluídos e a pilha é revertida. Todos os caracteres da pilha (ou seja, a primeira linha inteira) são impressos e, em seguida, passam para a segunda linha.

A segunda linha faz essencialmente a mesma coisa, exceto que está na direção oposta, portanto você não precisa inverter a pilha. (Eu faço assim mesmo, porque tenho que excluir os espaços finais.)

Finalmente, ele passa para a terceira linha. A única grande diferença é que você deve pular o bloco CJam, que é feito usando .A aspas simples captura a linha inteira (novamente, para trás) e, em seguida, é emitida.

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 bytes porque a compilação em C requer o sinalizador do compilador GCC -Dfunction=.

Como funciona (em PHP):

• O intérprete PHP simplesmente imprime tudo antes <?phpcomo HTML. //não é um comentário em HTML, por isso é simplesmente impresso.
• mainé declarada como uma função com uma variável a.
• printfimprime um retorno de carro (para substituir o já impresso //) e, em seguida, o código fonte, usando um método padrão de quining C / PHP.
• #if 0 é ignorado pelo PHP.
• main($a)inicializa uma variável vazia a. (Anteriormente usado error_reporting(0)para ignorar erros causados ​​por chamadas main())
• #endif também é ignorado pelo PHP.

Como funciona (em C):

• //<?php é um comentário de linha única, por isso é ignorado.
• A functionpalavra-chave é ignorada devido ao argumento do compilador da linha de comandos -Dfunction=.
• O GCC e o Clang não se importam se as variáveis ​​começam com ou contêm $. (Isso salvou o dia.)
• printf imprime um retorno de carro (inútil neste caso) e, em seguida, o código-fonte, usando um método padrão de quining C / PHP.
• #if 0ignora tudo até o endif, para que o PHP possa chamar main.
• #endif termina o bloco "ignore-me".

Wumpus / > <> / Befunge-98 28 bytes

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

Experimente em Wumpus! , Experimente em> <>! , Experimente-o em Befunge-98!

Como funciona:

Código 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

> <> Código:

  " 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

Código 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 bytes, não concorrente

0"D34çý"D34çý

Experimente online! (05AB1E)
Experimente online! (2sable)

2sable é derivado de 05AB1E e é semelhante, mas possui grandes diferenças.

Nova linha à direita.

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

Contém caracteres de controle.

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

Seu Vim precisa ter o seguinte conjunto:

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

Primeira linha intencionalmente em branco.

Perl / Javascript (SpiderMonkey), 106 bytes

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

Experimente o Perl online!
Experimente o JavaScript online!

Explicação

Os dados do quine são armazenados nos $_dois idiomas e depois evaleditados, o que é praticamente o procedimento padrão no Perl. Eu escolhi o SpiderMonkey no TIO, pois ele tem uma printfunção, mas isso pode ser facilmente transportado para o navegador por + 20 bytes (adicione eval("print=alert");ao início de$_ definição s).

O Perl vê os dados armazenados $_e os evalfaz como de costume. Desde que +[]é verdade em Perl, 'é armazenado $qatravés do stringwise-XOR de he O. O truque final está na chamada para printonde a primeira parte do JavaScript usa +, que no Perl trata todos os itens como números e soma 0, então usamos o ||operador para retornar o que realmente queremos (q($_),"=$q$_$q;",q(eval($_)))que seja equivalente "\$_=$q$_$q;eval(\$_)".

Em JavaScript, +[]retornos 0, então nós chamamos unescape("%27")a loja 'em $q(infelizmente, atobexistem doesm't em SpirderMonkey ...). Na chamada para print, uma vez que +é o operador de concatenação no JavaScript, o primeiro bloco cria a saída desejada e a segunda parte após a ||ignoração.

Obrigado ao comentário de Patrick Roberts para o unescapetruque!

Perl / JavaScript (navegador), 108 bytes

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

Experimente o Perl online!

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

Explicação

Nós armazenamos os dados do quine $_nos dois idiomas e, em seguida eval, eles, o que é praticamente um procedimento padrão no Perl.

O Perl vê os dados armazenados $_e os evalfaz como de costume. O evalinterior $_é executado e falha ao analisar, mas, como é eval, não gera erros. printfé então chamado, com uma única cadeia de caracteres entre aspas q(), com `como delimter, pois apenas o uso `resultaria em comandos sendo executados no shell; em seguida, para o primeiro uso de $q, uma vez que +[]é verdade no Perl, 'é armazenado $qvia stringwise-XOR de heO .

Em JavaScript, o evalbloco dentro $_configura uma função q, que returné seu argumento como a Stringe alias console.logpara printf, uma vez que console.logformata uma string como printfem Perl. Quando printfé chamado de +[]retorno 0, chamamos atobpara decodificar 'e armazenar $q.

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

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)

Verifique online!

Com base nas minhas atualizações para esta resposta , pensei em tentar otimizar o código que imprime uma permutação diferente, mas acabei adicionando o Bash, que adicionava mais bytes de qualquer maneira. Embora isso seja mais otimizado do que minha primeira tentativa (salva em mais de 300 bytes), tenho certeza de que ainda pode ser jogado mais.

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

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)

Verifique online!

Um pouco mais perto da minha abordagem original, mas a repetição de argumentos printfainda é insana. Em vez disso, usar argumentos posicionais faz com que isso funcione apenas no Chrome e é complicado começar a trabalhar no PHP também porque o $sin %1$sé interpolado, mas pode economizar muitos bytes, talvez usando uma combinação das duas abordagens ...

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

Aproveitando os comentários, sim!

Perl 5 / Ruby / PHP / JavaScript (Navegador), 153 bytes

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

Experimente o Perl online!
Experimente o Ruby online!
Experimente o 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($_);