Escreva um programa que, quando executado em idiomas diferentes, produza uma permutação de bytes diferente do código em cada idioma. O código fonte exato é contado como uma permutação.

Aqui "idioma diferente" pode ter uma versão diferente (Py 2 e Py 3) ou diferentes sinalizadores padrão. É uma saída diferente que força uma versão diferente.

Regras de quine apropriadas se aplicam ao programa em cada idioma. Sua pontuação é calculada como (Language count)^6/(Code length in bytes), com uma pontuação maior sendo melhor.

Amostra:

Se o seu código estiver AABem execução em três idiomas diferentes ABA, AABe AAB, sua pontuação será 2^6/3(apenas uma das duas AABconta). Tudo bem se ABAnão tiver sentido.

Befunge-98 , > <> , Gol> <> , fissão , Wumpus , Cardinal , cera de abelha e Alice Pontos: 8 ⁶ /88 = 2978,909

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

Experimente em Befunge! Experimente em> <>! Experimente em Gol> <>! Experimente em Fissão! Experimente em Wumpus! Experimente no cardeal! Experimente em cera de abelha! Experimente em Alice!

Verificação!

Muitas linguagens 2D, todas abusando de literais de string de quebra automática. A diferença nas saídas é assim:

> <>, Gol> <> e Befunge-98 imprimem o código para trás (exceto para "), com os três últimos caracteres em posições diferentes R*", O"*e "R*respectivamente. A cera de abelha também possui o código ao contrário, mas os três últimos caracteres são intercalados na primeira seção da saída. Alice está principalmente ao contrário, exceto por todos os caracteres de escape ( ', \e ") movidos para a frente.

Wumpus é o único quine atual, Fission coloca o "final do código em vez do começo, e Cardinal coloca o "intervalo entre 0o 5próximo e o próximo.

Prova de diferentes permutações

Explicações:

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

> <> e Gol> <>:

Para ser sincero, não fiz muito aqui. A única diferença entre a execução desses dois idiomas é o @comando, que gira os três principais valores da pilha de maneiras diferentes para cada idioma.

"  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

Fissão:

 "............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

Cardeal:

                                 %   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

Cera de abelha:

 "................*`*   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 , rubi , JavaScript (cromado), PHP , Python 2 , Python 3 , 1206 bytes, marcar 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,"%"))

Valide online Perl, Ruby, PHP, Python 2 e Python 3!

Nota : a execução do programa acima no console do Inspector no Chrome (que parece suportar argumentos posicionais para console.log) retorna o programa correto.

Explicação

Isso ficou muito mais tempo do que eu esperava e também tornei minha vida um pouco mais difícil, então provavelmente continuarei mexendo nela. Também gostaria de adicionar mais idiomas, mas preciso encontrar algo que não se importe com um $sigilo ...

Isso é muito bonito um formato Quine padrão onde o cálculo da cotação para uso é um pouco diferente para cada idioma: em Ruby %q&é usado, usa PHP ', JavaScript (Node.js) faz uso de `e Perl 5 utiliza q(... ). Como apenas as aspas mudam, o restante do programa ainda é executável e sintaxe válida em cada idioma. O Python 2 e 3 são agrupados em torno do programa anterior usando o """Python 2 e o '''Python 3.

Os programas Perl e Ruby resultantes não são quines padrão, q/ %qs adicionais são adicionados a cada iteração, mas o primeiro programa retorna corretamente.

Os resultados são:

• 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,"%"))

Eu refiz muito isso, espero não ter perdido nada importante aqui. Ainda tenho um caminho a percorrer em qualquer lugar perto da partitura de Jo King ...

Geleia , e M , 2 ⁶ /14 = 4,57

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

Experimente em geléia!

Experimente em M!

Ɗṙ@ȮṾ1“Ɗṙ@ȮṾ1” em geléia

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

Python 2 e Python 3 , 2 ⁶ /61 = 1,05

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

Experimente no Python 2!

Experimente no Python 3!

Economizou 12 bytes graças a Jo King.

Impressões em Python 2

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

Impressões em Python 3

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

Isso usa o fato de 1/2estar .5no Python 3 e 0no Python 2.

Bash / GolfScript, 72 bytes, marcar 2 ⁶ /72 = 8/9 (~ 0,888 ...)

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

Contém um único espaço à direita nas duas primeiras linhas.

Experimente online no Bash.
Experimente online no GolfScript.

Simplesmente a modificação da resposta de @ jimmy23013 para o desafio " Write a Polyquine " . A modificação feita foi remover o espaço à direita após a terceira linha e mudar \n"+@n.;para \n "+@n;.

O Bash imprimirá as linhas 1 e 2 da seguinte maneira:

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

E o GolfScript imprimirá as linhas 1 e 2 assim:

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

Aqui, o programa base, a saída Bash e a GolfScript, respectivamente, com as novas linhas substituídas por \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