Écrivez un programme qui, lorsqu'il est exécuté dans différentes langues, génère une permutation d'octets différente du code dans chaque langue. Le code source exact est compté comme une permutation.

Ici, «langue différente» peut être une version différente (Py 2 et Py 3) ou différents drapeaux standard. C'est une sortie différente qui force une version différente.

Des règles de quine appropriées s'appliquent au programme dans chaque langue. Votre score est calculé comme (Language count)^6/(Code length in bytes), un score plus élevé étant meilleur.

Échantillon:

Si votre code est AABet s'exécute dans trois langues différentes retourne ABA, AABet AAB, alors son score est 2^6/3(un seul des deux AABcompte). C'est bien si ça ABAn'a pas de sens.

Befunge-98 , > <> , Gol> <> , Fission , Wumpus , Cardinal , cire d' abeille et Alice Score: 8 ⁶ /88 = 2978,909

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

Essayez-le dans Befunge! Essayez-le dans> <>! Essayez-le dans Gol> <>! Essayez-le dans Fission! Essayez-le dans Wumpus! Essayez-le dans Cardinal! Essayez-le dans la cire d'abeille! Essayez-le dans Alice!

Vérification!

Beaucoup de langages 2D, tous abusant des littéraux de chaîne enveloppants. Les différences de sorties sont donc:

> <>, Gol> <> et Befunge-98 tous les imprimer en arrière de code (sauf pour le "), les trois derniers caractères dans des positions différentes, R*", O"*et "R*respectivement. La cire d'abeille a également le code à l'envers, mais les trois derniers caractères sont entrecoupés dans la première section de la sortie. Alice est principalement en arrière, à l'exception de tous les caractères échappés ( ', \et ") déplacés vers l'avant.

Wumpus est le seul quine réel, Fission place le "à la fin du code au lieu du début, et Cardinal place le "entre le 0et le 5près du début.

Preuve de différentes permutations

Explications:

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

> <> et Gol> <>:

Pour être honnête, je n'ai pas fait grand-chose ici. La seule différence entre l'exécution de ces deux langues est la @commande, qui fait tourner les trois premières valeurs de la pile de différentes manières pour chaque langue.

"  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

Fission:

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

Cardinal:

                                 %   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

Cire d'abeille:

 "................*`*   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 (chrome), PHP , Python 2 , python 3 , 1206 octets, le score de 6 ⁶ /1 206 = 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,"%"))

Validez Perl, Ruby, PHP, Python 2 et Python 3 en ligne!

Remarque : l'exécution du programme ci-dessus dans la console Inspector dans Chrome (qui semble prendre en charge les arguments de position console.log) renvoie le programme correct.

Explication

Cela s'est avéré beaucoup plus long que je ne l'avais espéré et j'ai rendu ma vie un peu plus difficile aussi, donc je vais probablement continuer à la bricoler. J'aimerais aussi ajouter plus de langues, mais je dois trouver quelque chose qui ne me dérange pas un $sceau ...

Ceci est à peu près un format standard Quine où le calcul de la citation à utiliser est un peu différent pour chaque langue: Ruby %q&est utilisé, utilise PHP ', JavaScript (Node.js) utilise `et Perl 5 Utilise q(... ). Étant donné que seules les guillemets changent, le reste du programme est toujours une syntaxe exécutable et valide dans chaque langue. Python 2 et 3 sont enroulés autour du programme précédent en utilisant """pour Python 2 et '''pour Python 3.

Les programmes Perl et Ruby résultants ne sont pas des quines standard, des q/ %qs supplémentaires sont ajoutés à chaque itération, mais le premier programme revient correctement.

Les résultats sont:

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

J'ai beaucoup retravaillé cela, j'espère que je n'ai rien oublié de clé ici. Il me reste encore beaucoup de chemin à parcourir pour être proche du score de Jo King ...

Gelée , et M , 2 ⁶ /14 = 4,57

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

Essayez-le dans Jelly!

Essayez-le en M!

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

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

Python 2 et Python 3 , 2 ^six / 61 = 1,05

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

Essayez-le en Python 2!

Essayez-le en Python 3!

Enregistré 12 octets grâce à Jo King.

Impressions Python 2

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

Impressions Python 3

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

Cela utilise le fait que 1/2c'est .5en Python 3 et 0en Python 2.

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

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

Contient un seul espace de fin sur les deux premières lignes.

Essayez-le en ligne dans Bash.
Essayez-le en ligne dans GolfScript.

Simplement modification de la réponse de @ jimmy23013 pour le challenge " Ecrire une Polyquine " . La modification qui a été effectuée supprimait l'espace de fin après la troisième ligne et passait \n"+@n.;à \n "+@n;.

Bash imprimera les lignes 1 et 2 comme ceci:

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

Et GolfScript imprimera les lignes 1 et 2 comme ceci:

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

Voici le programme de base, la sortie Bash et les sorties GolfScript respectivement avec les nouvelles lignes remplacées par \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