Poliquina jest zarówno quine, jak i polyglot. ¹ Musisz napisać quine, która jest ważna w co najmniej dwóch różnych językach. To jest kod golfowy, więc wygrywa najkrótsza odpowiedź (w bajtach).

_{¹ Wymyśliłem to. A raczej zrobili to Geobici . Najwyraźniej nie był też pierwszym .}

Zasady dla Quines

Akceptowane są tylko prawdziwe quines. Oznacza to, że musisz wydrukować cały kod źródłowy dosłownie do STDOUT, bez :

• czytanie kodu źródłowego, bezpośrednio lub pośrednio.
• polegając na środowisku REPL, które po prostu ocenia i drukuje każde podane wyrażenie.
• opierając się na funkcjach językowych, które w niektórych przypadkach drukują tylko źródło.
• za pomocą komunikatów o błędach lub STDERR, aby napisać całość lub część quine. (Możesz pisać różne rzeczy do STDERR lub generować ostrzeżenia / niekrytyczne błędy, o ile STDOUT jest poprawnym quine, a komunikaty o błędach nie są jego częścią.)

Ponadto twój kod musi zawierać literał ciągu.

Zasady dla Polyglots

Dwa używane języki muszą być wyraźnie różne. W szczególności:

• Nie mogą to być różne wersje tego samego języka (np. Python 2 vs. Python 3).
• Nie mogą to być różne dialekty tego samego języka (np. Pascal vs. Delphi).
• Jeden język może nie być podzbiorem drugiego (np. C vs. C ++).

CJam / GolfScript, 34 bajty

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

Liczba bajtów zawiera końcowe podawanie wiersza, ponieważ bez niego program nie byłby quine.

Podczas gdy CJam i GolfScript są bardzo podobne w niektórych aspektach, istnieje wiele różnic. Aby uczynić z tego „uczciwą” polikwinę, postanowiłem w jak największym stopniu polegać na różnicach . Z wyjątkiem składni bloków i łańcuchów (które języki współużytkują z tak wieloma innymi), żadna część kodu nie osiąga dokładnie tego samego w obu językach.

Interpreter online GolfScript ma błąd; ten program działa tylko z oficjalnym tłumaczem.

Przykładowy przebieg

$ 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

Jak to działa (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.                                                ";

Jak to działa (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 bajtów

{"0$~"N}0$~

Cheaty rozwiązanie, które w jak największym stopniu pozwala uniknąć różnic między językami.

Wypróbuj online:

• CJam
• GolfScript

Jak to działa (CJam)

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

Jak to działa (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 bajtów

Korzystam z właściwości, że znaki w Javie można zapisać jako identyczne sekwencje Unicode. Jeśli mamy Ainstrukcję dla kompilatora C # i Binstrukcję dla Java, możemy użyć następującego fragmentu kodu:

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

Będzie to „rozpoznawane” w następujący sposób za pomocą C #:

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

I w następujący sposób przez Javę:

//
/*
A//*/B

Z powodu podziału \u000Alinii \u002Fjest /i \u002Ajest *w Javie.

Ostateczna poliglota-quine to:

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

Jednak rozmiar jest zbyt duży ze względu na gadatliwość języków.

Kompilacja dostępna na ideone.com: C # , Java .

Python 3 i JavaScript, 134 bajty

Oto moja (ostatnia?) Próba:

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)

Prawdopodobnie można go nieco pograć w golfa, zwłaszcza jeśli ktoś zna lepszy sposób na uzyskiwanie pojedynczych cudzysłowów w JavaScript.

Gotowany program wygląda następująco:

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

eval()Funkcja oceni wyrażeń w obu językach. Tak więc długi łańcuch zostaje wykonany:

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

To dzieli długi łańcuch na spacje i ocenia podciąg indeksowany 2%-4. JavaScript uruchomi trzeci podciąg ( 2 % -4 == 2), a Python drugi ostatni ( 2 % -4 == -2), ponieważ ich operatory modulo zachowują się inaczej w przypadku negatywów.

Reszta ciągu jest ignorowana w obu językach. JavaScript zatrzymuje się na //, podczas gdy Python widzi go jako dzielenie liczb całkowitych i zatrzymuje się na #.

Więc JavaScript drukuje kod źródłowy na konsoli tutaj:

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

I Python tutaj:

print(a[-12:]%a)

Oba wykorzystują ostatnią część ciągu, który jest szablonem programu:

a=%r;eval(a)

Ruby / Perl / PHP, 52

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

Skopiowano dosłownie z Perla Quine Christophera Durra .

To jest nadużycie zasad. Ruby i Perl zdecydowanie nie są tym samym językiem, ani też Perl nie jest podzbiorem Rubiego (na przykład większość połączonych quinów Perla nie działa w Rubim). Ale Ruby został zaprojektowany tak, aby mógł wyglądać bardzo podobnie do Perla, jeśli tego chcesz, i dzieje się to często podczas gry w golfa.

Bash / GolfScript, 73

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

W każdym z pierwszych 3 wierszy znajduje się spacja.

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

Biegnij z:

$ php quine.pl
$ perl quine.pl

phpKod jest uruchomiony (nie tylko drukuje się).

Bash / Ruby, 104 82

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

Starsza wersja:

"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 bez niezdefiniowanego zachowania

"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

reticle / befunge-98, 28 bajtów [niekonkurencyjny]

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

Wypróbuj siatkę! Wypróbuj befunge 98!

Cokolwiek pomiędzy ;s w befunge jest ignorowane i !przeskakuje do segmentu między ;s dla siatki. Tak więc siatka widzi:

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

<@,+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 bajtów

Oto moja bardzo łatwa do wykonania polyquine (która służy jako przykład i dowód słuszności koncepcji):

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

Pierwsza część oparta jest na tym rubinowym quine i jest w zasadzie:

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

Przypisanie łańcucha jest dokładnie takie samo w Mathematica. puts s%sInterpretowany jest jako iloczyn: 4 symbole puts, łańcuch s, %(ostatni wynik REPL lub Out[0]jeśli jest to pierwszy wyraz ocenić) i inny s. To oczywiście zupełnie bez znaczenia, ale Mathematica nie dba o to i ;tłumi wszelkie dane wyjściowe, więc jest to po prostu przetwarzane w ciszy. Następnie #czyni resztę wiersza komentarzem dla Ruby, podczas gdy Mathematica kontynuuje.

Jeśli chodzi o kod Mathematica, największą jego część stanowi symulacja przetwarzania napisów w formacie Ruby bez użycia literałów. FromCharacterCode@{37,112}jest %pi FromCharacterCode@{37,112}jest %%. Pierwszy zostaje zastąpiony samym ciągiem (gdzie InputFormdodaje cudzysłowy) drugi zostaje zastąpiony pojedynczym %. Wynik jest Printedytowany. Ostatnim haczykiem jest, jak sobie z tym poradzić z #przodu. Jest to symbol Mathematica dla pierwszego argumentu funkcji czysto (anonimowej). Więc robimy to, aby uczynić to wszystko czystą funkcją przez dodanie &i natychmiastowe wywołanie funkcji z argumentem 1. Przygotowanie 1do wywołania funkcji „zwielokrotnia” wynik przez1, które Mathematica ponownie połyka, niezależnie od tego, jakie funkcje są zwracane przez funkcję.

> <> i CJam, 165 bajtów

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

Do CJam program zaczyna się od wieloliniowego literału łańcuchowego. Jest to `poprzedzane znakiem ucieczki , a następnie używa standardowej quine do wydrukowania kodu quine, a także końcowego komentarza.

Aby> <>, pierwszy "rozpoczyna literał ciąg, który przechodzi przez cały pierwszy wiersz, wypychając każdy znak na stos. Następnie spacje końcowe (utworzone z powodu uzupełniania danych wejściowych) są usuwane, a następnie stos jest odwracany. Każdy znak na stosie (tzn. Cały pierwszy rząd) jest wyprowadzany, a następnie przechodzi do drugiego rzędu.

Drugi rząd zasadniczo robi to samo, tyle że w przeciwnym kierunku, więc nie trzeba odwracać stosu. (Tak czy inaczej, bo muszę usunąć końcowe spacje).

Wreszcie przechodzi do trzeciej linii. Jedyną zasadniczą różnicą jest to, że musisz pominąć blok CJam, co odbywa się za pomocą .Pojedynczego cudzysłowu, przechwytuje całą linię (ponownie, wstecz), a następnie jest wyprowadzana.

C / PHP, 266 304 300 282 241 203 + 10 bajtów

//<?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 bajtów, ponieważ kompilacja w C wymaga flagi kompilatora GCC -Dfunction=.

Jak to działa (w PHP):

• Tłumacz PHP po prostu drukuje wszystko przed <?phpHTML. //nie jest komentarzem w HTML, więc jest po prostu drukowany.
• mainjest zadeklarowany jako funkcja ze zmienną a.
• printfwypisuje znak powrotu karetki (w celu zastąpienia już wydrukowanego //), a następnie kod źródłowy, przy użyciu standardowej metody quiningu C / PHP.
• #if 0 jest ignorowany przez PHP.
• main($a)inicjuje pustą zmienną a. (Wcześniej używane error_reporting(0)do ignorowania błędów spowodowanych wywołaniem main())
• #endif jest również ignorowane przez PHP.

Jak to działa (w C):

• //<?php jest komentarzem jednowierszowym, więc jest ignorowany.
• Słowo functionkluczowe jest ignorowane z powodu argumentu kompilatora wiersza poleceń -Dfunction=.
• GCC i Clang nie dbają o to, czy zmienne zaczynają się od, czy zawierają $. (To uratowało dzień.)
• printf wypisuje znak powrotu karetki (w tym przypadku bezużyteczny), a następnie kod źródłowy, używając standardowej metody quiningu C / PHP.
• #if 0ignoruje wszystko aż do endif, więc PHP może zadzwonić main.
• #endif kończy blok „ignoruj ​​mnie”.

Wumpus / > <> / Befunge-98 28 bajtów

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

Wypróbuj w Wumpus! , Wypróbuj w> <>! , Wypróbuj w Befunge-98!

Jak to działa:

Kod 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

> <> Kod:

  " 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

Kod 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 bajtów, niekonkurujący

0"D34çý"D34çý

Wypróbuj online! (05AB1E)
Wypróbuj online! (2sable)

2sable pochodzi z 05AB1E i jest podobny, ale ma duże różnice.

Końcowy znak nowej linii.

C / TCL, 337 bajtów

#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 bajtów

Zawiera znaki kontrolne.

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

Twój Vim musi mieć następujący zestaw:

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

C / Lisp, 555 bajtów

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

Celowo pusty pierwszy wiersz.

Perl / JavaScript (SpiderMonkey), 106 bajtów

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

Wypróbuj Perl online!
Wypróbuj JavaScript online!

Wyjaśnienie

Quine dane są przechowywane w $_obu językach, a następnie evaled, co jest prawie standardową procedurą w Perlu. Wybrałem SpiderMonkey na TIO, ponieważ ma on printfunkcję, ale można ją łatwo przenieść do przeglądarki na + 20 bajtów (dodaj eval("print=alert");na początek $_definicji s).

Perl widzi dane w nim przechowywane $_i evaljak zwykle. Ponieważ +[]jest prawdą w Perlu, 'jest przechowywany $qpoprzez ciąg XOR hi O. Ostatnia sztuczka polega na wywołaniu, w printktórym wykorzystuje pierwszą część JavaScript +, która w Perlu traktuje wszystkie elementy jako liczby i sumuje się 0, a następnie używamy ||operatora, aby zwrócić to, czego faktycznie chcemy, (q($_),"=$q$_$q;",q(eval($_)))co jest równoważne "\$_=$q$_$q;eval(\$_)".

W JavaScript, +[]powraca 0, więc zadzwonić unescape("%27")do sklepu 'w $q(Niestety, atobdoesm't istnieć w SpirderMonkey ...). W wywołaniu do print, ponieważ +w JavaScript jest operatorem konkatenacji, pierwszy blok buduje pożądane dane wyjściowe, a druga część po ||jest ignorowana.

Dzięki komentarzowi Patricka Robertsa do unescapesztuczki!

Perl / JavaScript (przeglądarka), 108 bajtów

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

Wypróbuj Perl online!

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

Wyjaśnienie

Przechowujemy dane quine $_w obu językach, a następnie evalto, co jest prawie standardową procedurą w Perlu.

Perl widzi dane w nim przechowywane $_i evaljak zwykle. Element evalwewnętrzny $_jest wykonywany i nie może zostać przeanalizowany, ale ponieważ evalnie jest błędny. printfjest następnie wywoływany, z pojedynczym cudzysłowem q(), z `jako separator, ponieważ samo użycie `spowoduje wykonanie poleceń w powłoce, a następnie dla pierwszego użycia $q, ponieważ +[]jest to prawdą w Perlu, 'jest przechowywane w $qciągu XOR ciągu hi O.

W JavaScript evalblok wewnątrz $_ustawia funkcję q, która returnjest jej argumentem jako Stringaliasy console.logdo printf, ponieważ console.logformatuje ciąg znaków jak printfw Perlu. Kiedy printfnazywa się +[]zwraca 0, więc wzywamy atobdo dekodowania 'i przechowywania $q.

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

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)

Sprawdź to online!

Opierając się na moich aktualizacjach tej odpowiedzi , pomyślałem, że spróbuję zoptymalizować kod, który wypisuje inną permutację, ale ostatecznie dodałem Bash, który i tak dodał ładowanie więcej bajtów. Chociaż jest to bardziej zoptymalizowane niż moja pierwsza próba (zapisano ponad 300 bajtów), jestem pewien, że można go jeszcze pograć w golfa.

Alternatywne Perl 5 / Ruby / JavaScript (Node.js) / Bash / Python 2 / PHP , 1040 bajtów

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)

Sprawdź to online!

Nieco bliżej mojego pierwotnego podejścia, ale powtarzanie argumentów za printfjest nadal szalone. Użycie zamiast tego argumentów pozycyjnych sprawia, że ​​działa to tylko w Chrome i trudno jest również pracować w PHP, ponieważ $sin %1$sjest interpolowany, ale może zaoszczędzić wiele bajtów, być może stosując kombinację dwóch podejść ...

C / dc, 152 bajty

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

Korzystając z komentarzy, tak!

Perl 5 / Ruby / PHP / JavaScript (przeglądarka), 153 bajty

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

Wypróbuj Perl online!
Wypróbuj Ruby online!
Wypróbuj 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($_);