Una poliquina es quine y polyglot. ¹ Debe escribir un quine que sea válido en al menos dos idiomas diferentes. Este es el código de golf, por lo que gana la respuesta más corta (en bytes).

_{¹ Lo inventé. O más bien, Geobits lo hizo . Aparentemente, tampoco fue el primero .}

Reglas para Quines

Solo se aceptan quines verdaderos . Es decir, debe imprimir el código fuente completo textualmente a STDOUT, sin :

• leyendo su código fuente, directa o indirectamente.
• confiando en un entorno REPL que simplemente evalúa e imprime cada expresión que le da de comer.
• confiando en las características del lenguaje que solo imprimen la fuente en ciertos casos.
• usando mensajes de error o STDERR para escribir todo o parte de la línea. (Puede escribir cosas a STDERR o generar advertencias / errores no fatales siempre que STDOUT sea una quine válida y los mensajes de error no formen parte de ella).

Además, su código debe contener un literal de cadena.

Reglas para políglotas

Los dos idiomas utilizados deben ser claramente diferentes. En particular:

• No deben ser versiones diferentes del mismo lenguaje (por ejemplo, Python 2 frente a Python 3).
• No deben ser dialectos diferentes del mismo idioma (por ejemplo, Pascal vs. Delphi).
• Un idioma puede no ser un subconjunto del otro (por ejemplo, C vs. C ++).

CJam / GolfScript, 34 bytes

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

El recuento de bytes contiene un salto de línea final, ya que el programa no sería una quine sin él.

Si bien CJam y GolfScript son muy similares en algunos aspectos, hay muchas diferencias. Para hacer de esta una poliquina "honesta", decidí confiar en las diferencias lo más posible. Excepto por la sintaxis de bloques y cadenas (que los idiomas comparten con tantos otros), ninguna parte del código logra exactamente lo mismo en ambos idiomas.

El intérprete en línea de GolfScript tiene un error; Este programa solo funciona con el intérprete oficial.

Ejecución de ejemplo

$ 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

Cómo 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.                                                ";

Cómo 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$~

Solución atractiva que evita las diferencias de los idiomas tanto como sea posible.

Pruébalo en línea:

• CJam
• GolfScript

Cómo funciona (CJam)

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

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

Uso la propiedad de que los caracteres en Java se pueden escribir como secuencias idénticas de Unicode. Si tenemos Ainstrucciones para el compilador de C # e Binstrucciones para Java, podemos usar el siguiente fragmento de código:

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

Será "reconocido" de la siguiente manera con C #:

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

Y de la siguiente manera por Java:

//
/*
A//*/B

Debido a que \u000Aes un salto de línea, \u002Festá /y \u002Aestá *en Java.

Entonces el políglota quino final es:

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

Sin embargo, el tamaño es demasiado grande debido a la verbosidad de los idiomas.

Compilación disponible en ideone.com: C # , Java .

Python 3 y JavaScript, 134 bytes

Aquí está mi intento (¿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)

Probablemente se pueda jugar un poco más, especialmente si alguien conoce una mejor manera de obtener comillas simples en JavaScript.

En resumen, el programa se ve así:

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

La eval()función evaluará expresiones en ambos idiomas. Entonces la cadena larga se ejecuta:

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

Esto divide la cadena larga por espacios y evalúa la subcadena indexada por 2%-4. JavaScript ejecutará la tercera subcadena ( 2 % -4 == 2) y Python la segunda ( 2 % -4 == -2), porque sus operadores de módulo se comportan de manera diferente para los negativos.

El resto de la cadena se ignora en ambos idiomas. JavaScript se detiene en el //, mientras que Python lo ve como una división entera y se detiene en el #.

Entonces JavaScript imprime el código fuente en la consola aquí:

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

Y Python aquí:

print(a[-12:]%a)

Ambos hacen uso de la parte final de la cadena, que es una plantilla del 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 textualmente de Christopher Durr Perl quine .

Esto es abuso de reglas. Ruby y Perl definitivamente no son el mismo idioma, ni Perl es un subconjunto de Ruby (la mayoría de las quines Perl vinculadas no funcionan en Ruby, por ejemplo). Pero Ruby fue diseñado para poder parecerse mucho a Perl si así lo desea, y esto sucede mucho cuando juega al golf.

Bash / GolfScript, 73

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

Hay un espacio final en cada una de las primeras 3 líneas.

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

Corre con:

$ php quine.pl
$ perl quine.pl

El phpcódigo se está ejecutando (no solo imprimiéndose).

Bash / Ruby, 104 82

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

Versión antigua:

"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 sin comportamiento 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 [sin competencia]

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

Prueba reticular! ¡Prueba befunge 98!

Cualquier cosa entre ;s en befunge se ignora y !salta al segmento entre ;s para reticular. Por lo tanto, reticular ve:

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

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

Aquí está mi propia policina muy batible (que sirve como ejemplo y prueba de concepto):

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 primera parte se basa en este quine de Ruby y es básicamente:

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

La asignación de cadena es exactamente la misma en Mathematica. El puts s%sse interpreta como un producto de 4 símbolos:, putsla cadena s, %(el último resultado REPL o Out[0]si es la primera expresión que evalúa) y otra s. Por supuesto, eso no tiene sentido, pero a Mathematica no le importa y ;suprime cualquier salida, por lo que esto se procesa en silencio. Luego# hace que el resto de la línea sea un comentario para Ruby mientras Mathematica continúa.

En cuanto al código de Mathematica, la mayor parte del mismo, es simular el procesamiento de cadenas de formato de Ruby sin usar ningún literal de cadena. FromCharacterCode@{37,112}es %py FromCharacterCode@{37,112}es %%. El primero se reemplaza con la cadena en sí, (donde se InputFormagregan las comillas), el último con una sola %. El resultado es Printed. La captura final es cómo lidiar con eso #en el frente. Este es el símbolo de Mathematica para el primer argumento de una función pura (anónima). Entonces, lo que hacemos es hacer de todo eso una función pura al agregar &e invocar inmediatamente la función con argumento 1. Anteponiendo a1 llamada a una función "multiplica" el resultado con1, que Mathematica nuevamente se traga independientemente de qué tipo de cosa devuelve la función.

> <> y 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, el programa comienza con un literal de cadena de varias líneas. Esto se escapa con `, y luego utiliza la quine estándar para imprimir el código de quine, así como un comentario final.

Para> <>, el primero " comienza un literal de cadena que recorre toda la primera fila, empujando cada carácter a la pila. Después de eso, los espacios finales (creados debido a la entrada que se está rellenando) se eliminan, y luego la pila se invierte. Todos los caracteres de la pila (es decir, la primera fila completa) se muestran y luego se mueven hacia la segunda fila.

La segunda fila esencialmente hace lo mismo, excepto que está en la dirección opuesta, por lo que no necesita invertir la pila. (Lo hago de todos modos, porque tengo que eliminar los espacios finales).

Finalmente, pasa a la tercera línea. La única diferencia importante es que debe omitir el bloque CJam, lo que se hace usando .La comilla simple captura la línea completa (nuevamente, hacia atrás) y luego se genera.

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 compilar en C requiere el indicador del compilador GCC -Dfunction=.

Cómo funciona (en PHP):

• El intérprete PHP simplemente imprime todo antes de <?php HTML. //no es un comentario en HTML, por lo que simplemente se imprime.
• main se declara como una función con una variable a .
• printf imprime un retorno de carro (para anular el ya impreso // ) y luego el código fuente, utilizando un método estándar de quining C / PHP.
• #if 0 es ignorado por PHP.
• main($a)Inicializa una variable vacía a. (Anteriormente utilizado error_reporting(0)para ignorar errores causados ​​por llamadasmain() )
• #endif también es ignorado por PHP.

Cómo funciona (en C):

• //<?php es un comentario de una sola línea, por lo que se ignora.
• La functionpalabra clave se ignora debido al argumento del compilador de línea de comandos-Dfunction= .
• A GCC y Clang no les importa si las variables comienzan o contienen $ . (Esto salvó el día).
• printf imprime un retorno de carro (inútil en este caso) y luego el código fuente, utilizando un método estándar de quining C / PHP.
• #if 0ignora todo hasta el endif, por lo que PHP puede llamar main.
• #endif finaliza el bloque "ignorarme".

Wumpus / > <> / Befunge-98 28 bytes

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

¡Pruébalo en Wumpus! ¡ Pruébalo en> <>! ¡ Pruébalo en Befunge-98!

Cómo 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, no competidor

0"D34çý"D34çý

Pruébalo en línea! (05AB1E) ¡
Pruébelo en línea! (2sable)

2sable se deriva de 05AB1E y es similar, pero tiene grandes diferencias.

Nueva línea final.

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

Contiene caracteres de control.

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

Su Vim necesita tener el siguiente 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 */);} 

Primera línea intencionalmente en blanco.

Perl / Javascript (SpiderMonkey), 106 bytes

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

Prueba el Perl en línea!
¡Prueba el JavaScript en línea!

Explicación

Los datos de quine se almacenan en $_ambos idiomas y luego se evaleditan, que es un procedimiento bastante estándar en Perl. Elegí SpiderMonkey en TIO ya que tiene una printfunción, pero esto podría ser fácilmente transferido al navegador por + 20 bytes (agregar eval("print=alert");al comienzo de$_ la definición s).

Perl ve los datos almacenados $_y evallos guarda como de costumbre. Como +[]es verdad en Perl, 'se almacena a $qtravés de stringwise-XOR deh y O. El truco final está en la llamada a printdonde usa la primera parte de JavaScript +, que en Perl trata todos los elementos como números y suma 0, luego usamos el ||operador para devolver lo que realmente queremos, lo (q($_),"=$q$_$q;",q(eval($_)))que es equivalente "\$_=$q$_$q;eval(\$_)".

En JavaScript, +[]devuelve 0, así que llamamosunescape("%27") a la tienda 'en $q(por desgracia, atobexisten doesm't en SpirderMonkey ...). En la llamada a print, dado que +es el operador de concatenación en JavaScript, el primer bloque genera la salida deseada y la segunda parte después de que ||se ignora.

¡Gracias al comentario de Patrick Roberts por el unescapetruco!

Perl / JavaScript (navegador), 108 bytes

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

Prueba el Perl en línea!

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

Explicación

Almacenamos los datos de quine en $_ en ambos idiomas y luego eval, que es un procedimiento bastante estándar en Perl.

Perl ve los datos almacenados $_y evallos guarda como de costumbre. El evalinside $_se ejecuta y no se analiza, pero como es así eval, no se produce un error. printfluego se llama, con una sola cadena entre comillas q(), con `el delimitador, ya que el solo uso `daría como resultado que los comandos se ejecuten en shell, luego, para el primer uso de $q, ya que +[]es cierto en Perl, 'se almacena en$q través de stringwise-XOR de hyO .

En JavaScript, el evalbloque dentro $_establece una función q, que returnes su argumento como una Stringy alias console.loga printf, ya que console.loglos formatos de cadena como printfen Perl. Cuando printfse llama+[] retorna 0, entonces llamamos atobpara decodificar 'y almacenar $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)

¡Verifíquelo en línea!

Basado en mis actualizaciones a esta respuesta , pensé que intentaría optimizar el código que imprime una permutación diferente, pero terminé agregando Bash, que de todos modos agregó una carga de más bytes. Si bien esto está más optimizado que mi primer intento (guardado más de 300 bytes), estoy seguro de que aún se puede jugar más.

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)

¡Verifíquelo en línea!

Un poco más cerca de mi enfoque original, pero la repetición de los argumentos printfsigue siendo una locura. El uso de argumentos posicionales en su lugar hace que esto solo funcione en Chrome y también es difícil comenzar a trabajar en PHP porque el $sin %1$sestá interpolado, pero podría ahorrar muchos bytes, tal vez usando una combinación de los dos enfoques ...

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

Aprovechando los comentarios, ¡sí!

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

Prueba el Perl en línea!
Prueba el Ruby en línea!
Prueba el PHP en línea!

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