# Quine of orders

Write a program that, when run in different languages, outputs a different byte permutation of the code in each language. The exact source code is counted as one permutation.

Here "different language" can be different version(Py 2 and Py 3) or different standard flags. It's different output that forces different version.

Proper quine rules apply for the program in each language. Your score is calculated as (Language count)^6/(Code length in bytes), with a higher score being better.

Sample:

If your code is AAB and running in three different languages returns ABA, AAB and AAB, then its score is 2^6/3(only one of the two AAB count). It's fine if ABA is meaningless.

• What counts as a different language? – Laikoni Apr 12 '18 at 9:24
• Which definition of a proper quine applies? (Martin's, or ais523's, or maybe some other definition in these meta threads?) Do the proper quine rules apply only to interpretations of the program that are actually quines? (For what it's worth, I don't think this challenge is improved much by enforcing proper quine rules.) – Lynn Apr 12 '18 at 9:28
• To clarify, working on your example — if my code AAB prints AAB in language-1 and ABA in language-2, I assume that it must be a proper quine when viewed as a language-1 program, and there are no further restrictions involving its interpretation as a language-2 program. Is that right? – Lynn Apr 12 '18 at 9:31
• Is code length counted in characters or bytes? What should we do with different character encodings? – dylnan Apr 12 '18 at 19:34
• What about bytes vs. characters? – dylnan Apr 13 '18 at 3:41

# Befunge-98, ><>, Gol><>, Fission, Wumpus, Cardinal, Beeswax and Alice Score: 86/88 = 2978.909

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


Verification!

Lots of 2D languages, all abusing wrapping string literals. The difference in outputs are thus:

><>, Gol><> and Befunge-98 all print the code backwards (except for the "), with the last three characters in different positions, R*", O"* and "R* respectively. Beeswax also has the code backwards, but the last three characters are interspersed in the first section of the output. Alice is mostly backwards, except for all the escaped characters (',\ and ") moved to the front instead.

Wumpus is the only actual quine, Fission puts the " at the end of the code instead of the beginning, and Cardinal puts the " between the 0 and the 5 near the start.

Proof of different permutations

## Explanations:

### 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  ### ><> and Gol><>: To be honest, I didn't do much here. The only difference between the execution of these two languages is the @ command, which rotates the top three values of the stack in different ways for each language. " 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


### Beeswax:

 "................**   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 bytes, score 66/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,"%"))  Validate Perl, Ruby, PHP, Python 2 and Python 3 online! Note: running the above program in the Inspector console in Chrome (which appears to support positional arguments to console.log) returns the correct program. ### Explanation This turned out a lot longer than I'd hoped and I made my life a little harder too, so I'm likely to keep tinkering with it. I'd like to add in more languages too, but I need to find something that doesn't mind a $ sigil...

This is pretty much a standard quine format where the calculation of the quote to use is a little different for each language: in Ruby %q& is used, PHP uses ', JavaScript (Node.js) makes use of  and Perl 5 utilises q(...). Because only the quotes change, the rest of the program is still executable and valid syntax in each language. Python 2 and 3 are wrapped around the previous program using """ for Python 2 and ''' for Python 3.

The resultant Perl and Ruby programs aren't standard quines, additional q/%qs are added each iteration, but the first program returns correctly.

The results are:

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

I've re-worked this a lot, I hope I haven't missed anything key here. I still have quite a way to go to be anywhere near Jo King's score...

# Jelly, and M, 26/14 = 4.57

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


Try it in Jelly!

Try it in M!

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

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

• I'm not sure that the Charcoal one counts as a proper quine – H.PWiz Apr 12 '18 at 17:13
• @H.PWiz I was about to add a comment saying that. I'll ask OP – dylnan Apr 12 '18 at 17:15
• @l4m2 do you consider the Charcoal program a proper quine? I will delete if not. – dylnan Apr 12 '18 at 17:16
• I guess it's like Quine in PHP? – l4m2 Apr 12 '18 at 17:35
• @l4m2 Not sure, I don't know PHP. It works for most ASCII text I think – dylnan Apr 12 '18 at 17:38

# Python 2 and Python 3, 26/61 =1.05

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


Try it in Python 2!

Try it in Python 3!

Saved 12 bytes thanks to Jo King.

Python 2 prints

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


Python 3 prints

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


This uses the fact that 1/2 is .5 in Python 3 and 0 in Python 2.

# Bash/GolfScript, 72 bytes, score 26/72 = 8/9 (~0.888...)

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


Contains a single trailing space on the first two lines.

Simply modification of @jimmy23013's answer for the "Write a Polyquine" challenge. The modification that was done was removing the trailing space after the third line, and changing \n"+@n.; to \n "+@n;.

Bash will print lines 1 and 2 like this:

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


And GolfScript will print lines 1 and 2 like this:

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


Here the base program, Bash output, and GolfScript outputs respectively with the new-lines replaced with \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