Napisz program, który po uruchomieniu w różnych językach generuje inną bajtową permutację kodu w każdym języku. Dokładny kod źródłowy jest liczony jako jedna permutacja.

Tutaj „innym językiem” może być inna wersja (Py 2 i Py 3) lub różne standardowe flagi. Różna moc wyjściowa wymusza inną wersję.

W każdym języku obowiązują odpowiednie zasady dotyczące quine. Twój wynik jest obliczany jako (Language count)^6/(Code length in bytes), przy czym wyższy wynik jest lepszy.

Próba:

Jeśli kod działa AABi działa w trzech różnych językach, zwraca ABA, AABa AABnastępnie jego wynik to 2^6/3(tylko jeden z dwóch się AABliczy). W porządku, jeśli ABAjest bez znaczenia.

Befunge-98 , > <> , Gol> <> , Rozszczepienie , wumpusa , kard , wosk pszczeli i Alicja Wynik: 8 ⁶ /88 = 2978,909

"65*4+059*$!#.39*0jp2+'Wk,@ ''5&.'\d&o@o&88#+\@ol?!,'.'0.6'!+Ox,++tttt=++%-$#}.6~.F4*`*R

Wypróbuj w Befunge! Wypróbuj w> <>! Wypróbuj w Gol> <>! Wypróbuj w Fission! Wypróbuj w Wumpus! Spróbuj w Kardynale! Wypróbuj wosk pszczeli! Wypróbuj w Alice!

Weryfikacja!

Wiele języków 2D, wszystkie nadużywające zawijanie literałów łańcuchowych. Różnica w wynikach jest zatem:

> <>, Gol> <> i befunge-98 wszystko wydrukować kierunku do tyłu kodu (z wyjątkiem "), z trzech ostatnich znaków w różnych pozycjach R*", O"*a "R*odpowiednio. Wosk pszczeli ma również kod wstecz, ale trzy ostatnie znaki są przeplatane w pierwszej sekcji wyniku. Alice jest głównie do tyłu, z wyjątkiem wszystkich zbiegłych znaków ( ', \i ") przeniósł się do przodu zamiast.

Wumpus jest jedyną rzeczywistą quine, Fission umieszcza "na końcu kodu zamiast na początku, a Kardynał umieszcza "pomiędzy 0i 5blisko początku.

Dowód różnych permutacji

Objaśnienia:

Befunge-98:

"  Wrapping string literal pushes all other characters + a space to the stack
 65*4+  Push " to the stack
      059*$!#.39*0j   Push 1,27 to the stack
                   p  Pops the top three values of the stack (27,1,34)
                    2+  Adds 2 to the space to make "
                      'Wk,@  Prints the top 88 characters of the stack and terminates

> <> i Gol> <>:

Szczerze mówiąc, niewiele tu zrobiłem. Jedyną różnicą między wykonywaniem tych dwóch języków jest @polecenie, które obraca trzy górne wartości stosu na różne sposoby dla każdego języka.

"  Wrapping string literal pushes all other characters to the stack
 65*4+  Push 34 (") to the stack
      059*$!#.  Jump to cell 45,0
                                   \@  Rotate the top three values of the stack 
                                     ol?!,'.'0.  Output the whole stack, ending in a divide by 0/stack underflow error

Rozszczepienie:

 "............R  Spawn a pointer going right

 "  Switch to printing mode and print every other character
 "  Switch off printing mode
  6  Teleport to other 6
 "........6'!+O   Print the "

Wumpus:

"  Bouncing string literal
 65*4+  Push a (")
      059*$!#.   Push 0 and jump to cell 0,45
                                        \  Reflect off mirror
                                       +   Add 0 to top of stack
                                 @o&88#    Print the top 88 characters of the stack

Kardynał:

                                 %   Spawn two pointer going left/right (up/down despawn immediately)
                                  -$  Right pointer jumps to cell -1,0
                      x,++tttt=++     Left pointer prints "
"  While right pointer switches to print mode and prints the code

Wosk:

 "................*`*   Spawn pointers going in every direction
                        Every other * also spawns pointers, but they do nothing
                   `    Turn on print mode for two of the pointers going in different directions
                        This prints everything but the `
          #}.6~.F4*     Print a `

Alice:

"  Wrapping string literal pushes all other characters to the stack
   Except 's and mirrors
 65*4+  Push " to the stack
      059*$!#.  Does nothing
              39*0j  Jumps to cell 39,0
                         ''5&.    Push ' and duplicate it 5 times
                              '\  Push \
                                d&o@  Print the whole stack

Perl 5 , Ruby , JavaScript (chrom), PHP , Python 2 , Python 3 , 1206 bajtów, wynik 6 ⁶ /1206 = +38,6865671641791

q=1//2;s=+0;s|0;"/.__id__;#";_="""q=1//2;s=+0;s|0;"/.__id__;#";_={0}{1}{0};R=chr((39,34)[1/2>0])*12;Q=chr((39,34)[1/2==0])*3;q={0}{2}{0};print(_.format(Q,_,q[0:-12]+R,"%"))""";R=chr((39,34)[1/2>0])*12;Q=chr((39,34)[1/2==0])*3;q="""|;#<?ob_end_clean();
eval($_='"$t"?0?[$q=37 .chr+113 .chr+38 .chr,$p=(96 .chr+39 .chr)*4,$n=10 .chr,$s=39 .chr*12,$S=34 .chr*3]:eval("printf=console.log;c=String.fromCharCode;$q=c(96);$p=c(37,113,38,39).repeat(4);$n=c(10);$s=c(39).repeat(12);$S=c(34,34,34)"):[]?[$q=q(!g)^PA,$p=HARHARHARHAR^od2od2od2od2,$n=R^X,$s=bbbbbbbbbbbb^EEEEEEEEEEEE,$S=hhh^JJJ]:[$q=O^h,$p=str_repeat(RHa3^w9GS,4),$n=R^X,$s=str_repeat(b^E,12),$S=HHH^jjj];//#');printf($x='q=1//2;s=+0;s|0;"/.__id__;#";_=%7$sq=1//2;s=+0;s|0;"/.__id__;#";_={0}{1}{0};R=chr((39,34)[1/2>0])*12;Q=chr((39,34)[1/2==0])*3;q={0}{2}{0};print(_.format(Q,_,q[0:-12]+R,"%8$s"))%7$s;R=chr((39,34)[1/2>0])*12;Q=chr((39,34)[1/2==0])*3;q=%7$s|;#<?ob_end_clean();%5$seval($_=%3$s%1$s%3$s);printf($x=%3$s%2$s%3$s,$_,$x,$q,$p,$n,$s,$S,"%8$s",![]||([]+[])?$n:"");//#%4$s%6$s%7$s;print(_.format(Q,_,q[0:-12]+R,"%8$s"))%9$s',$_,$x,$q,$p,$n,$s,$S,"%",![]||([]+[])?$n:"");//#`q&%`q&%`q&%`q&%''''''''''''""";print(_.format(Q,_,q[0:-12]+R,"%"))

Sprawdź poprawność Perla, Ruby, PHP, Python 2 i Python 3 online!

Uwaga : uruchomienie powyższego programu w konsoli Inspector w Chrome (która wydaje się obsługiwać argumenty pozycyjne console.log) zwraca właściwy program.

Wyjaśnienie

Okazało się to o wiele dłużej, niż się spodziewałem, a moje życie też stało się trochę trudniejsze, więc prawdopodobnie będę go majstrować. Chciałbym również dodać więcej języków, ale muszę znaleźć coś, co nie $miałoby nic przeciwko sigil ...

Jest to dość dużo standardowy format Quine gdzie obliczenie środki do wykorzystania jest trochę inna dla każdego języka: w Ruby %q&jest stosowany, wykorzystuje PHP ', JavaScript (node.js) wykorzystuje `i Perl 5 wykorzystuje q(... ). Ponieważ zmieniają się tylko cudzysłowy, reszta programu jest nadal wykonywalna i poprawna składnia w każdym języku. Python 2 i 3 są owinięte wokół poprzedniego programu przy użyciu """Python 2 i '''Python 3.

Wynikowe programy Perl i Ruby nie są standardowymi quinesami, dodatkowe q/ %qs są dodawane przy każdej iteracji, ale pierwszy program zwraca poprawnie.

Wyniki są następujące:

• Perl 5:
  eval($_=q&... q&);printf($x=q&... q&,... );//#'%`'%`'%`'%`''''''''''''"""...
• Ruby:
  eval($_=%q&... %q&);printf($x=%q&... %q&,... );//#`'`'`'`'''''''''''''"""...
• JavaScript (Chrome):
  eval($_=`... `);printf($x=`... `,... );//#%q&'%q&'%q&'%q&'''''''''''''"""...
• PHP:
  eval($_='... ');printf($x='... ',... );//#`q&%`q&%`q&%`q&%''''''''''''"""...
• Python 2:
  ... _="""... """;... q="""...''''''''''''""";print(_.format(Q,_,q[0:-12]+R,"%"))
• Python 3:
  ... _='''... ''';... q='''...""""""""""""''';print(_.format(Q,_,q[0:-12]+R,"%"))

Dużo to przerabiałem, mam nadzieję, że nie przegapiłem tutaj żadnego klucza. Nadal mam spory sposób, aby znaleźć się gdzieś blisko wyniku Jo Kinga ...

Galaretki i M , 2 ⁶ /14 = 4,57

1Ɗṙ@“1Ɗṙ@ȮṾ”ȮṾ

Wypróbuj w galarecie!

Wypróbuj w M!

Ɗṙ@ȮṾ1“Ɗṙ@ȮṾ1” w galarecie

1Ɗṙ@ȮṾ“1Ɗṙ@ȮṾ” w M.

Pyton 2 i pyton 3 , 2 ⁶ /61 = z 1,05

s='s=%r;print(s%%s[::(1/2>0)*2-1])';print(s%s[::(1/2>0)*2-1])

Wypróbuj w Python 2!

Wypróbuj w Python 3!

Zaoszczędzono 12 bajtów dzięki Jo Kingowi.

Odbitki w języku Python 2

s=')]1-2*)0>2/1(::[s%%s(tnirp;r%=s';print(s%s[::(1/2>0)*2-1])

Odbitki w języku Python 3

s='s=%r;print(s%%s[::(1/2>0)*2-1])';print(s%s[::(1/2>0)*2-1])

Wykorzystuje to fakt, że 1/2jest .5w Python 3 i 0Python 2.

Atakujących / GolfScript 72 bajtów, wynik 2 ⁶ /72 = 8/9 (~ 0,888 ...)

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

Zawiera pojedyncze końcowe miejsce w pierwszych dwóch wierszach.

Wypróbuj online w Bash.
Wypróbuj online w GolfScript.

Po prostu modyfikacja odpowiedzi @ jimmy23013 na wyzwanie „ Write a Polyquine ” . Dokonana modyfikacja polegała na usunięciu spacji po trzeciej linii i zmianie \n"+@n.;na \n "+@n;.

Bash wydrukuje linie 1 i 2 w następujący sposób:

.~0 ()    <- Trailing space
{         <- Trailing space

A GolfScript wydrukuje linie 1 i 2 w następujący sposób:

.~0 ()   <- No trailing space
 {       <- Both leading and trailing space

Tutaj program bazowy, wyjście Bash i dane GolfScript odpowiednio z nowymi wierszami zastąpionymi przez \n:

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

      ^^^ Note the difference here