Una polilinea è sia quine che poliglotta. ¹ Devi scrivere un quine valido in almeno due lingue diverse. Questo è il golf del codice, quindi vince la risposta più breve (in byte).

_{^{1 L'} ho inventato. O meglio, Geobits l'ha fatto . Apparentemente, non era neanche il primo , però.}

Regole per Quines

Sono accettate solo vere quine. Cioè, è necessario stampare l'intero codice sorgente su STDOUT, senza :

• leggendo il codice sorgente, direttamente o indirettamente.
• basandosi su un ambiente REPL che semplicemente valuta e stampa ogni espressione che gli dai da mangiare.
• basandosi su funzionalità linguistiche che in alcuni casi stampano semplicemente l'origine.
• usando messaggi di errore o STDERR per scrivere tutto o parte del quine. (È possibile scrivere elementi su STDERR o produrre avvisi / errori non fatali purché STDOUT sia un quine valido e i messaggi di errore non ne facciano parte.)

Inoltre, il codice deve contenere una stringa letterale.

Regole per poliglotti

Le due lingue utilizzate devono essere nettamente diverse. In particolare:

• Non devono essere versioni diverse della stessa lingua (ad esempio Python 2 vs. Python 3).
• Non devono essere dialetti diversi della stessa lingua (ad es. Pascal vs. Delphi).
• Una lingua potrebbe non essere un sottoinsieme dell'altra (ad es. C vs. C ++).

CJam / GolfScript, 34 byte

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

Il conteggio dei byte contiene un avanzamento riga finale, poiché il programma non sarebbe un quine senza di esso.

Mentre CJam e GolfScript sono molto simili in alcuni aspetti, ci sono molte differenze. Per rendere questa una poliammina "onesta", ho deciso di fare affidamento il più possibile sulle differenze . Fatta eccezione per la sintassi di blocco e stringa (che le lingue condividono con oh così tanti altri), nessuna parte del codice raggiunge esattamente lo stesso in entrambe le lingue.

L'interprete GolfScript online ha un bug; questo programma funziona solo con l'interprete ufficiale.

Esempio di esecuzione

$ 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

Come funziona (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.                                                ";

Come funziona (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 byte

{"0$~"N}0$~

Soluzione economica che evita il più possibile le differenze linguistiche.

Provalo online:

• CJam
• GolfScript

Come funziona (CJam)

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

Come funziona (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 byte

Uso la proprietà che i caratteri in Java possono essere scritti come sequenze unicode identiche. Se abbiamo Aistruzioni per il compilatore C # e Bistruzioni per Java, possiamo usare il seguente frammento di codice:

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

Sarà "riconosciuto" nel modo seguente con C #:

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

E nel modo seguente da Java:

//
/*
A//*/B

A causa della sua \u000Ainterruzione di linea, \u002Fè /ed \u002Aè *in Java.

Quindi l'ultimo poliglotta-quine è:

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

Tuttavia, la dimensione è troppo grande a causa della verbosità delle lingue.

Compilazione disponibile su ideone.com: C # , Java .

Python 3 e JavaScript, 134 byte

Ecco il mio (ultimo?) Tentativo:

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)

Probabilmente può essere giocato a golf un po 'di più, soprattutto se qualcuno conosce un modo migliore per ottenere virgolette singole in JavaScript.

In breve, il programma si presenta così:

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

La eval()funzione valuterà le espressioni in entrambe le lingue. Quindi viene eseguita la stringa lunga:

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

Ciò divide la stringa lunga per spazi e valuta la sottostringa indicizzata da 2%-4. JavaScript eseguirà la terza sottostringa ( 2 % -4 == 2) e Python la seconda ( 2 % -4 == -2), perché i loro operatori modulo si comportano diversamente per i negativi.

Il resto della stringa viene ignorato in entrambe le lingue. JavaScript si ferma a //, mentre Python lo vede come divisione di interi e si ferma a #.

Quindi JavaScript stampa il codice sorgente sulla console qui:

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

E Python qui:

print(a[-12:]%a)

Entrambi fanno uso della parte finale della stringa, che è un modello del programma:

a=%r;eval(a)

Ruby / Perl / PHP, 52

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

Copiato letteralmente dal Perl quine di Christopher Durr .

Questo è un abuso di regole. Ruby e Perl non sono sicuramente la stessa lingua, né Perl è un sottoinsieme di Ruby (la maggior parte dei quines Perl collegati non funzionano in Ruby, per esempio). Ma Ruby è stato progettato per essere in grado di assomigliare molto al Perl se lo desideri, e questo accade molto durante il golf.

Bash / GolfScript, 73

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

C'è uno spazio finale su ciascuna delle prime 3 righe.

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

Corri con:

$ php quine.pl
$ perl quine.pl

Il phpcodice è effettivamente in esecuzione (non solo la stampa stessa).

Bash / Ruby, 104 82

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

Versione precedente:

"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 senza comportamento indefinito

"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

reticolare / befunge-98, 28 byte [non competitivo]

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

Prova reticolare! Prova befunge 98!

Qualsiasi cosa tra ;s in befunge viene ignorata e !passa al segmento tra ;s per reticolare. Pertanto, la reticolare vede:

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

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

Ecco la mia poliammina molto battibile (che funge da esempio e proof-of-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 prima parte si basa su questo quino di Ruby ed è sostanzialmente:

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

L'assegnazione delle stringhe è esattamente la stessa in Mathematica. Il puts s%sviene interpretato come un prodotto di 4 simboli puts:, la stringa s, %(l'ultimo risultato REPL o Out[0]se è la prima espressione che valuti) e un'altra s. Questo è ovviamente completamente insignificante, ma Mathematica non si preoccupa e ;sopprime qualsiasi output, quindi questo viene elaborato silenziosamente. Quindi #rende il resto della linea un commento per Ruby mentre Mathematica continua.

Per quanto riguarda il codice Mathematica, la parte più grande di esso, è simulare l'elaborazione delle stringhe di formato di Ruby senza usare letterali di stringa. FromCharacterCode@{37,112}è %ped FromCharacterCode@{37,112}è %%. Il primo viene sostituito con la stringa stessa, (dove InputFormaggiunge le virgolette) il secondo con un singolo %. Il risultato è Printed. Il trucco finale è come affrontarlo #nella parte anteriore. Questo è il simbolo di Mathematica per il primo argomento di una funzione pura (anonima). Quindi quello che facciamo è rendere tutto ciò una funzione pura aggiungendo &e invocando immediatamente la funzione con argomento 1. Preparare 1a una chiamata di funzione "moltiplica" il risultato con1, che Mathematica di nuovo ingoia di nuovo indipendentemente dal tipo di cosa restituito dalla funzione.

> <> e CJam, 165 byte

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

Per CJam, il programma inizia con una stringa multilinea letterale. Questo è evaso con` e quindi usa lo standard quine per stampare il codice quine, oltre a un commento finale.

A> <>, il primo " inizia una stringa letterale che attraversa l'intera prima riga, spingendo tutti i personaggi in pila. Successivamente, gli spazi finali (creati a causa dell'input che viene riempito) vengono eliminati, quindi lo stack viene invertito. Ogni personaggio nella pila (cioè l'intera prima riga) viene emesso, quindi si sposta in basso verso la seconda riga.

La seconda riga essenzialmente fa la stessa cosa, tranne per il fatto che è nella direzione opposta, quindi non è necessario invertire la pila. (Lo faccio comunque, perché devo eliminare gli spazi finali.)

Infine, passa alla terza riga. L'unica grande differenza è che devi saltare il blocco CJam, che viene fatto usando .La virgoletta singola cattura l'intera linea (di nuovo, all'indietro), e quindi viene emessa.

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

//<?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 perché la compilazione in C richiede il flag del compilatore GCC -Dfunction=.

Come funziona (in PHP):

• L'interprete PHP stampa semplicemente tutto prima <?phpdell'HTML. //non è un commento in HTML, quindi è semplicemente stampato.
• mainviene dichiarato come una funzione con una variabile a.
• printfstampa un ritorno a capo (per sovrascrivere il già stampato //) e quindi il codice sorgente, utilizzando un metodo di quining C / PHP standard.
• #if 0 viene ignorato da PHP.
• main($a)inizializza una variabile vuota a. (Precedentemente utilizzato error_reporting(0)per ignorare gli errori causati dalla chiamata main())
• #endif viene anche ignorato da PHP.

Come funziona (in C):

• //<?php è un commento a riga singola, quindi viene ignorato.
• La functionparola chiave viene ignorata a causa dell'argomento del compilatore della riga di comando -Dfunction=.
• A GCC e Clang non importa se le variabili iniziano o contengono $. (Questo ha salvato la giornata.)
• printf stampa un ritorno a capo (inutile in questo caso) e quindi il codice sorgente, utilizzando un metodo di quining C / PHP standard.
• #if 0ignora tutto fino a quando endif, quindi PHP può chiamare main.
• #endif termina il blocco "Ignorami".

Wumpus / > <> / Befunge-98 28 byte

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

Provalo in Wumpus! , Provalo in> <>! , Provalo in Befunge-98!

Come funziona:

Codice 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

> <> Codice:

  " 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

Codice 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 byte, non concorrenti

0"D34çý"D34çý

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

2sable è derivato da 05AB1E ed è simile, ma presenta differenze sostanziali.

Newline finale.

C / TCL, 337 byte

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

Contiene caratteri di controllo.

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

Il tuo Vim deve avere il seguente set:

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

C / Lisp, 555 byte

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

Prima riga intenzionalmente vuota.

Perl / Javascript (SpiderMonkey), 106 byte

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

Prova il Perl online!
Prova JavaScript online!

Spiegazione

I dati di Quine sono archiviati in $_entrambe le lingue e quindi evaled, che è una procedura praticamente standard in Perl. Ho scelto SpiderMonkey su TIO in quanto ha una printfunzione, ma questo potrebbe essere facilmente trasferito nel browser per + 20 byte (aggiungere eval("print=alert");all'inizio di$_ definizione s).

Perl vede i dati archiviati $_ed evalè come al solito. Dato che +[]è vero in Perl, 'è memorizzato $qtramite X-stringhe di he O. Il trucco finale è nella chiamata a printdove utilizza la prima parte per JavaScript +, che in Perl tratta tutti gli elementi come numeri e li aggiunge 0, quindi usiamo l' ||operatore per restituire ciò che vogliamo effettivamente (q($_),"=$q$_$q;",q(eval($_)))che è equivalente "\$_=$q$_$q;eval(\$_)".

In JavaScript, +[]i rendimenti 0, in modo che noi chiamiamo unescape("%27")a negozio 'a $q(purtroppo, atobesistono doesm't in SpirderMonkey ...). Nella chiamata a print, poiché +è l'operatore di concatenazione in JavaScript, il primo blocco crea l'output desiderato e la seconda parte dopo che ||viene ignorata.

Grazie al commento di Patrick Roberts per il unescapetrucco!

Perl / JavaScript (browser), 108 byte

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

Prova il Perl online!

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

Spiegazione

Archiviamo i dati di Quine $_in entrambe le lingue e quindieval , che è una procedura praticamente standard in Perl.

Perl vede i dati archiviati $_ed evalè come al solito. L' evalinterno $_viene eseguito e non riesce ad analizzare, ma dato che è eval, non si sbaglia . printfviene quindi chiamato, con una singola stringa tra virgolette q(), con `come delimitatore, poiché il solo utilizzo `comporterebbe l'esecuzione di comandi nella shell, quindi per il primo utilizzo di $q, poiché +[]è vero in Perl, 'viene archiviato $qtramite stringwise-XOR di heO .

In JavaScript, il evalblocco all'interno $_imposta una funzione q, che returns il suo argomento come Stringe alias console.loga printf, dal momento che console.logstringa di formati, come printfin Perl. Quando printfviene chiamato +[]restituisce 0, quindi chiamiamo atobper decodificare 'e archiviare $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)

Verifica online!

Sulla base dei miei aggiornamenti a questa risposta , ho pensato di provare a ottimizzare il codice che stampa una permutazione diversa, ma alla fine ho aggiunto Bash, che ha aggiunto comunque un carico di più byte. Anche se questo è più ottimizzato del mio primo tentativo (salvato oltre 300 byte), sono sicuro che può ancora essere ulteriormente giocato a golf.

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

Verifica online!

Un po 'più vicino al mio approccio originale, ma la ripetizione degli argomenti per printf è ancora folle. L'uso di argomenti posizionali invece fa funzionare questo solo in Chrome ed è difficile farlo funzionare anche in PHP perché $sin %1$sè interpolato, ma potrebbe salvare molti byte, magari usando una combinazione dei due approcci ...

C / dc, 152 byte

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

Approfittando dei commenti, sì!

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

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