Schreiben Sie ein Programm, das bei Ausführung in verschiedenen Sprachen eine unterschiedliche Byte-Permutation des Codes in jeder Sprache ausgibt. Der genaue Quellcode wird als eine Permutation gezählt.

Hier kann "unterschiedliche Sprache" unterschiedliche Versionen (Py 2 und Py 3) oder unterschiedliche Standardflags sein. Es ist eine andere Ausgabe, die eine andere Version erzwingt.

Für das Programm gelten in jeder Sprache die richtigen Quine-Regeln. Ihre Punktzahl wird berechnet als (Language count)^6/(Code length in bytes), wobei eine höhere Punktzahl besser ist.

Stichprobe:

Wenn Ihr Code ist AABund in drei verschiedenen Sprachen zurückkehrt läuft ABA, AABund AABdann ist seine Punktzahl 2^6/3(nur eine der beiden AABZählung). Es ist in Ordnung, wenn ABAes bedeutungslos ist.

Befunge-98 , > <> , Gol> <> , Fission , Wumpus , Cardinal , Beeswax und 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

Probieren Sie es in Befunge! Probieren Sie es in> <>! Probieren Sie es in Gol> <>! Probieren Sie es in Fission! Probieren Sie es in Wumpus! Probieren Sie es in Cardinal! Probieren Sie es in Bienenwachs! Probieren Sie es in Alice!

Nachprüfung!

Viele 2D-Sprachen, die alle Wrapping-String-Literale missbrauchen. Die Leistungsunterschiede sind also:

> <>, Gol> <> und Befunge-98 alle Codes rückwärts ( mit Ausnahme des Druck "), mit den letzten drei Zeichen in verschiedenen Positionen, R*", O"*und "R*jeweils. Bienenwachs hat den Code auch rückwärts, aber die letzten drei Zeichen sind im ersten Abschnitt der Ausgabe eingestreut. Alice ist meistens rückwärts, mit Ausnahme aller entkommenen Zeichen ( ', \und "), die stattdessen nach vorne verschoben wurden.

Wumpus ist das einzige tatsächliche Quine, Fission setzt das "am Ende des Codes anstelle des Anfangs und Cardinal setzt das "zwischen das 0und das 5nahe am Anfang.

Nachweis unterschiedlicher Permutationen

Erklärungen:

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

> <> und Gol> <>:

Um ehrlich zu sein, habe ich hier nicht viel gemacht. Der einzige Unterschied zwischen der Ausführung dieser beiden Sprachen ist der @Befehl, mit dem die drei obersten Werte des Stapels für jede Sprache auf unterschiedliche Weise gedreht werden.

"  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

Kardinal:

                                 %   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

Bienenwachs:

 "................*`*   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 , Rubin , JavaScript (Chrom), PHP , Python 2 , Python 3 , 1206 Bytes, Score 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,"%"))

Validieren Sie Perl, Ruby, PHP, Python 2 und Python 3 online!

Hinweis : Wenn Sie das obige Programm in der Inspector-Konsole in Chrome ausführen (was anscheinend Positionsargumente unterstützt console.log), wird das richtige Programm zurückgegeben.

Erläuterung

Das war viel länger als ich gehofft hatte und ich habe mein Leben auch ein bisschen schwieriger gemacht, also werde ich wahrscheinlich weiter daran basteln. Ich möchte auch weitere Sprachen hinzufügen, aber ich muss etwas finden, das kein $Siegel stört ...

Das ist so ziemlich ein Standard quine Format , bei dem die Berechnung der Quote zu verwenden ein wenig anders für jede Sprache ist: in Ruby %q&verwendet wird, PHP Anwendungen ', JavaScript (Node.js) nutzt `und Perl 5 nutzt q(... ). Da sich nur die Anführungszeichen ändern, ist der Rest des Programms weiterhin ausführbar und die Syntax in jeder Sprache gültig. Python 2 und 3 werden mit """Python 2 und '''Python 3 um das vorherige Programm gewickelt .

Die resultierenden Perl- und Ruby-Programme sind keine Standard-Quines. Bei jeder Iteration werden zusätzliche q/ %qs hinzugefügt, aber das erste Programm wird korrekt zurückgegeben.

Die Ergebnisse sind:

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

Ich habe das viel überarbeitet, ich hoffe, ich habe hier keinen Schlüssel verpasst. Ich habe noch einen weiten Weg vor mir, um in der Nähe von Jo Kings Punktzahl zu sein ...

Jelly und M , 2 ⁶ /14 = 4,57

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

Probieren Sie es in Jelly!

Probieren Sie es in M!

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

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

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

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

Probieren Sie es in Python 2 aus!

Probieren Sie es in Python 3!

Dank Jo King wurden 12 Bytes gespeichert.

Python 2 druckt

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

Python 3 druckt

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

Dies nutzt die Tatsache , dass 1/2ist .5in Python 3 und 0in Python 2.

Heftiger Schlag / GolfScript, 72 Bytes, Score 2 ⁶ /72 = 8/9 (~ 0,888 ...)

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

Enthält ein einzelnes Leerzeichen in den ersten beiden Zeilen.

Probieren Sie es online in Bash aus.
Probieren Sie es online in GolfScript aus.

Ändern Sie einfach die Antwort von @ jimmy23013 für die Herausforderung " Write a Polyquine " . Die Modifikation, die durchgeführt wurde , wurde das Entfernen der Leerzeichen nach der dritten Zeile, und Ändern \n"+@n.;zu \n "+@n;.

Bash druckt die Zeilen 1 und 2 folgendermaßen:

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

Und GolfScript druckt die Zeilen 1 und 2 folgendermaßen:

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

Hier werden die Basisprogramm-, Bash-Ausgabe- und GolfScript-Ausgaben jeweils durch die neuen Zeilen ersetzt durch \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