Leaderboard

Luckily, the first line is a valid regex. However that regex obviously doesn't match the empty input, so the first stage (consisting of the first two lines) doesn't do anything.

The third line is on its own, so it's treated as a Match stage which, by default, counts the number of matches. However, the ` is a separator which tells Retina that the part in front of it is a configuration string (it doesn't happen to know any of the options given there) and the part after it is the regex. So the regex is empty and Retina finds exactly one match.

Starry prints `2`

Starry ignores everything except spaces and +*,'`.. Each command is one of those characters in conjunction with the spaces since the last of those characters. So let's remove all the extraneous code:

       + +'`. `

Seven spaces followed by + pushes a 2. One space followed by a + duplicates it. ' is a conditional jump. It pops the top of the stack, which is truthy (positive), so it jumps to the corresponding label (where labels are indicated by ` and "corresponding" means "with the same number of leading spaces"), which is the first `. . without spaces in front of it then prints the top of the stack as a number.

Prelude prints `3`

This assumes the Python interpreter which uses numeric output. Let's remove all the no-ops:

# 5        ?         + +3    8   9
15 7  -- !   31

The first voice does a bunch of stuff, but nothing of it matters, because there is no ! to print any of the results. The second voice pushes a 1, then a 5, then a 7. We take the difference of the last two to get -2, and then subtract that from the 1 to get 3. ! prints it. The third voice has only no-ops.

ETA prints `4`

ETA ignores everything except the characters ETAOINSH (in any case). So the code as seen by ETA is:

IaeeNTHneaSOeea

I tries to read input but can't, so it pushes -1. a pushes the current line number plus 1, which is 2. e is divmod, which replaces those with 0 and 1 (or -1, I don't actually know, but it doesn't matter). The next e replaces both of them with 0.

Now the interesting part. NTHne is a base-7 number literal. N and e are just the delimiters, and the three digits are THN. That is 54 (where T is digit 1, H is 0 and n is 5). a pushes 2 once more. S subtracts it, resulting in 52 and O outputs it as a character (4). Now e tries divmod again, but the stack contains two zeroes, so the program terminates with an error (but doesn't pollute STDOUT while doing so).

Axo prints `5`

This language was pretty much single-handedly responsible for the rewrite. I couldn't have the } on the first line because it would block for input in Axo (see revision history for what I'm talking about). For Axo, only this part of the code is relevant:

#I5aeeNTH{\

Luckily, Axo also has implicit 0s at the bottom of its stack, because # pops the top of the stack (to check if the next instruction should be skipped or not). The letters are all no-ops. Then 5 pushes a 5, { prints it, \ terminates the program. Quite simple, really.

Labyrinth prints `6`

I'm truncating the code a bit, because the right half is never reached, and I'm also using t in place of \t, so that the columns line up correctly:

#I5aeeNTH{\
15}7'`--~!@
 teaww`

Now that letters, spaces and tabs are walls in Labyrinth, so the accessible code actually looks like this:

# 5      {\
15}7'`--~!@
      `

The instruction pointer will automatically follow that path. # pushes the depth of the main stack (0) and 15 turns it into a 15. } moves it off to the auxiliary stack, and we're not going to use it any more. That conveniently makes the top of the stack zero, so that the IP does not turn left onto the 5. 7 turns the zero into a 7, ' is a no-op. The ` is unary negation, so we get -7. Now - subtracts the -7 from the implicit 0 underneath making it 7. This time, the IP does turn right to the `, which is unary negation, so we get 7 again. The IP hits a dead end a turns around. The - does the same thing as before, so we get 7 once more. As the top of the stack is now positive, the IP turns right. There's another - which gives -7 again. Then ~ is bitwise NOT, which gives 6 and ! prints it. That's just the right moment to do so, because now the stack is empty again such that the IP won't turn left onto the { but instead continues straight ahead into the @ which terminates the program.

Hexagony prints `7`

The unfolded code looks like this:

     # I 5 a e
    e N T H { \
   ? + + 3 ; n @
  " 8 " e a 9 1 5
 } 7 ' - - ~ ! @ <
  " 3 1 " L S O e
   . e a w w . .
    . . . . . .
     . . . . .

Normally, that would be a terrifying Hexagony program, but the characters actually in use are not too many. In fact they are pretty much the same as those used by Labyrinth and I think the way I differentiate between 5 and 6 is quite nice. :)

The top row can basically be ignored. # would normally switch to a different IP, but the current memory edge is 0, so it doesn't. The letters just set a fixed memory value, but we're not going to use it. After the end of the first row, control flow continues in the middle row (starting from the }, going right). The } moves to another memory edge. 7 sets that edge to 7. ' moves back to where we came from. - subtracts the memory edge we've just set to 7 from an unused memory edge (0), so we get -7. The next - does the same thing again, so it's a no-op. So far, quite similar to Labyrinth (apart from the memory layout). But now ~ is not bitwise NOT but unary negation in Hexagony. So this gives 7 instead of 6. !@, like in Labyrinth prints the value and terminates the program.

Foo prints `8`

As we all know since The Programming Language Quiz printing things is quite trivial in Foo, even if most of the code is a random jumble of characters. None of the characters affect the output except the "8" which prints 8. Well, there is the "31" later on, but Foo terminates with an error at the end of the first line. I'm not exactly sure why that happens, but it requires that 3 (or any other digit) on the top row, which isn't used anywhere else.

Brian & Chuck prints `9`

Let's do this thing again where we remove the third line (it's never parsed) and replace all irrelevant characters (i.e. no-ops, or cells that aren't read) with spaces:

         { ?         + +         9
  }   --   <        .

Just as a reminder, each line is a Brainfuck-like whose tape is the source code of the other program. Control flow starts on the first line (called Brian).

The { moves the tape head all the way to the left (where it already is), and ? hands control flow over to Chuck (the second line). There, } moves the tape head to the right until it finds a zero cell. That doesn't happen until the end of the program, so the tape head ends up one cell after the 9. - decrements that cell, but that's irrelevant. < moves the tape head onto the 9 and . prints it. Chuck runs out of program and terminates.

Gol><> prints `10`

Tested here.

# is a mirror, so the IP immediately skips to the end of the first line (and goes left). The 9 can be ignored. a pushes 10, e pushes 14, "8" pushes the character code of 8, @ rotates the top three stack elements (pulling up the 10), such that n prints the 10 and ; terminates the program.

Thanks to Sp3000 for suggesting to use @ instead of ! (which saved a byte).

evil prints `11`

Thanks to Sp3000 for sending me some brute-forced command-lists to generate single-digit numbers.

evil ignores everything except lower case letters so the code looks like this:

aeeneaeeaww

Also, n affects some state we don't care about so let's ignore that as well. Now a increments the register (which starts at 0), and e is evil's magic "weave" operation which permutes the bits in a particular way. aeeeaeea happens to yield the value 49 which is the character code of 1. ww prints it twice.

Whitespace prints `12`

Okay, we know Whitespace only reads spaces, tabs and linefeeds, so let write the code as seen by Whitespace with STL:

SSSSSSTTSSLTLST

That's two commands:

SSSSSSTTSSL
TLST

The first one pushes the number 12. Specifically, SS starts a number literal. The next S is the sign bit (positive). Then everything up to the L is a binary representation of the number. There's a ton of leading zeroes, which we need for Starry, but they don't affect the number. Then the TTSSs is 12 in binary. Fun fact: if I added a 16th language, I could save a byte here, because Starry could use the four S in the binary represtation of 16. I doubt I will though...

The TLST just prints the top of the stack as a number. (TL marks the command as an I/O command, and ST is printing numbers.)

Fission prints `13`

Fission only sees this part of the code:

           <"31"L

L starts control flow with a left-going atom. " toggles print mode, so that 31 just prints 13. Then the atom is captured in the wedge of the <, which terminates the program.

><> prints `14`

Tested here.

Distinguishing between ><> and Gol><> isn't as easy as I thought, because Gol><> almost always does the same thing as ><> for commands that exist in both, and commands that only exist in Gol><> cause ><> to crash. However, @ rotates the other way round in ><>, such that it pushes down the 7 instead of pulling up the 10, and then the 14 gets printed instead of the 10.

GolfScript prints `15`

This one is simplest: # comments out the first line. Then 15 pushes itself and } is a "super comment", which ignores the entire rest of the program. So the 15 is printed at the end of the program.

Martin Ender

Posted 2015-12-03T13:20:41.150

Reputation: 184 808

34This is really impressive! – sweerpotato – 2015-12-03T16:16:37.483

Nice job, very impressive indeed ! Then 5(!@ just sets the memory edge to 5, increments it, shouldn't it be decrements it since 4 is printed? I do not know the language so I can not check the logic behind it – Yassin Hajaj – 2015-12-03T20:58:35.743

1@YassinHajaj Thanks, corrected. – Martin Ender – 2015-12-03T21:00:13.917

@MartinButtner: What would you get if the question used 0-based indexing rather than 1-based indexing? – None – 2015-12-04T06:35:54.447

@RickyDemer hard to say. It wouldn't save or cost anything immediately, but I could probably ditch one character somewhere. It would probably be more helpful for adding further languages, because currently the only one that is easily adaptable for two digits is ><>, so getting another single digit would make some more room. – Martin Ender – 2015-12-04T07:25:36.200

Adding a whitespace program to this would be fairly trivial. Sadly, the 11 characters required to print 11 is 3 characters too many to lower your score at all. – SnoringFrog – 2015-12-04T15:50:51.450

@SnoringFrog Indeed. If I manage to add more languages so that I have more leeway for adding another language, I might reconsider it. When adding Whitespace it might be possible to add Starry for one or two more characters, so adding both of those at once might help. I'll have to look into that later. – Martin Ender – 2015-12-04T15:53:32.260

2Niiice. Great job for 15 languages! – ev3commander – 2015-12-05T22:51:26.547

1@SnoringFrog Well, there you go. – Martin Ender – 2015-12-05T22:52:24.483

i vote for this to get the bounty, thats just totally amazing – Eumel – 2015-12-07T11:58:06.557

1@Eumel Thanks, but the bounty is specifically for the "normal" languages listed in its description, so the bounty should go to such an answer (like Sp3000's very nice solution). I think I got enough rep from this anyway. ;) – Martin Ender – 2015-12-07T12:09:27.903

@MartinBüttner at least 1030 rep from this answer – ev3commander – 2015-12-07T20:59:56.840

@ev3commander not quite, considering the rep cap ;). Still more than enough – Martin Ender – 2015-12-07T21:00:43.563

Oh I forgot facepalms ;) – ev3commander – 2015-12-07T21:20:26.727

truly remarkable – Aᴄʜᴇʀᴏɴғᴀɪʟ – 2016-01-09T04:16:01.623

Couldn't the issue with Axo be avoided by piping from /dev/null, which is allowed by default?

– Mego – 2016-04-21T05:09:18.263

@Mego Since I only tried Axo on TIO, I assumed that the interpreter would already receive an empty stream anyway. Maybe it doesn't though, I don't know, but at this point, I don't really feel like rewriting it once more. ;) – Martin Ender – 2016-04-21T06:47:58.453

@MartinBüttner You don't feel like shaving off several bytes? Who are you and what have you done with Martin? – Mego – 2016-04-21T07:01:53.237

@Mego I do feel like shaving off several bytes, but I don't feel like spending another 4 hours trying to understand the program(s) again and rewriting it once more. This answer was definitely exhausting. ;) ... Maybe some day... – Martin Ender – 2016-04-21T07:07:16.560

Python 1.x, 2.x and 3.x, 32 bytes / 3^3 = 1.1851...

import sys
print(sys.version[0])

Prints the first number of the version, which is 1 in Python 1.x, 2 in Python 2.x and 3 in Python 3.x.

By the time we get Python 9.x my score will be a glorious 0.04389!

:~)!

sweerpotato

Posted 2015-12-03T13:20:41.150

Reputation: 2 457

10From chat: Yes, this is both cheap and valid =) This is part of the reason why only major versions were considered unique enough. I don't know how many Python versions there are, but you could probably get your score pretty darn low using something like this... It's one of the few solutions where I actually understand what is happening, so +1 from me ;-) – Stewie Griffin – 2015-12-03T17:32:31.383

6In python 10.x (when it exists) wouldn't it print 1 because it's the first character of the string "10.whatever"? – ev3commander – 2015-12-04T20:15:36.197

1@ev3commander However, this submission isn't spec'd to produce a correct output in python10. – Tyzoid – 2015-12-08T12:26:44.633

Fixed! Working on a future-proof version, but Python 1.x isn't as user-friendly as the others :~)! – sweerpotato – 2015-12-08T17:08:00.450

1All I need to do is create a language that has three major versions. In those three major versions, when running an empty file returns the major version number. The result would be 0 / 3^3 = 0

Perfect. – Braden Steffaniak – 2015-12-09T21:55:34.087

3 languages, 2 bytes / 27 = 0.074

1P

Well, it beats half the submissions at least :P

1. GolfScript

GolfScript ignores the P, outputting just the 1. Try it online.

2. Par

P is 2-to-the-power-of, so 1P = 2^1 = 2. Try it online.

3. Seriously

P gives the nth prime, zero indexed. We get 3 since that's the second prime. Try it online.

Notes

My inital goal was to find a valid answer in 1 byte. My first try was \x12 which works in Bubblegum and gs2, but the challenge requires a minimum of three languages. \x13 would work if there's a language in which that outputs 1.

Giving up on a 1 byte answer, I moved to two bytes. 3u is a close call, outputting 1 in Japt, 3 in GolfScript and 4 in Seriously, but it was hard to find a language which outputted 2 to fill the gap.

All of this took me way too long :/

Sp3000

Posted 2015-12-03T13:20:41.150

Reputation: 58 729

6 Languages - 44 bytes / 6^3 = 0.204...

Thanks to SnoringFrog for saving 10 bytes!

Works in:

Befunge
Pyth
Brainfuck
Hexagony
Whitespace
AniRad v0.2

2# "1",@"-[----->+<]>.*@@@!4<SSTST
T
ST
 >6=

Note: Before trying it online, make sure to replace S with spaces and T with tabs, or convert the following hexdump to ASCII

32 23 20 22 31 22 2c 40 22 2d 5b 2d 2d 2d 2d 2d 3e 2b 3c 5d 3e 2e 2a 40 40 40 21 34 3c 20 20 09 20 09 0d 0a 09 0d 0a 20 09 0d 0a 20 3e 36 3d

I am going to try to use more programming languages :)

Befunge (prints `1`):

2# "1",@"-[----->+<]>.*@@@!4<
2                             # This puts 2 onto the stack
 #                            # Skips the next op (the space)
   "1"                        # Sets the ASCII value of 1 onto the stack
      ,                       # Pop the last item (1)
       @                      # Terminate program

Pyth (prints `2`):

2# "1",@"-[----->+<]>.*@@@!4<
2                             # Prints 2
 #                            # Infinite while loop until an error occurs
   "1"                        # String
      ,@                      # This gives the error and terminates the program

Brainfuck (prints `3`):

2# "1",@"-[----->+<]>.*@@@!4<
2# "1",@"                     # Since these are not brainfuck ops, these will be ignored
         -[----->+<]>         # Puts "3" on the stack
                     .        # Prints the last item (3)

Hexagony (prints `4`):

2# "1",@"-[----->+<]>.*@@@!4<

A more readable version:

   2 # " 1       # The steps:
  " , @ " -      # 1 (2) - Hexagony starts at the top-left of the hexagon
 [ - - - - -     #       - This immediately puts 2 onto the stack
> + < ] > . *    # 2 (#) - Since the stack is 2, this makes the 2nd pointer the 
 @ @ @ ! 4 <     #       - new current pointer
  > 6 = . .      # 3 (*) - The position of the 2nd pointer is in the left-most
   . . . .       #       - position. This sets the stack to the product
                         - of the two neighbours which is zero
                 # 4 (<) - Changes the pointer direction to west
                 # 5 (4) - Sets the stack to 4
                 # 6 (!) - Outputs the decimal 4
                 # 7 (@) - Terminates the program

Whitespace (prints `5`):

Since other characters are ignored but whitespaces and tabs, we are left with the following:

SSTST                 # This pushes 5 onto the stack
T                     # 
ST                    # This prints the decimal

AniRad version 0.2 (prints `6`):

Somehow this works for version 0.2, but gives an error for version 0.4. I have no clue why. You can find version 0.2 here. In order to run this, you can copy and paste the interpreter's code to repl.it and run it. After that, you only need to paste the program to STDIN and run it.

2# "1",@"-[----->+<]>.*@@@!4<      # (#)  Starts at the hashtag (starting point)
                                   #      Direction is down
                                   # (>)  When the pointer gets to the '>', it changes
 >6=                               #      its direction
                                   # (6) Puts 6 onto the stack 
                                   # (=) Pushes the result and terminates

Adnan

Posted 2015-12-03T13:20:41.150

Reputation: 41 965

1More languages is definitely the way to go I think... the cubic denominator is really generous, so that it shouldn't be too hard to beat my score once you have 5 or 6 languages. – Martin Ender – 2015-12-03T14:22:03.893

@MartinBüttner, Yes, although I can't see how to add a new language – Adnan – 2015-12-03T14:25:37.483

2@Martin yes, it's generous. The point of the cubic denominator was to strongly encourage more languages. I think 6 languages in 50 bytes should be worth the same as 5 languages in 30 bytes. :-) it will definitely get harder the more languages you use. – Stewie Griffin – 2015-12-03T14:36:34.123

Your Whitespace code could be reduced a bit (and I don't think it'll affect any of your other languages. (Using L for linefeed), instead of the SSSSSSSSSSTTSTSTLTLSS you have now, you can do SSSTSTLTLST. This pushes a literal 5 on the stack, then prints as integer. – SnoringFrog – 2015-12-04T15:04:16.033

@SnoringFrog Thanks! I have edited it – Adnan – 2015-12-04T15:18:11.797

6 7 languages, 32 37 bytes, score 0.148... 37/7³ ≈ 0.107872...

#7+!"@\"6.@;n5
print(4--int(-3/2)#"
)

Brainfuck-ng

+ increments current cell, ! prints as integer, @ exits. # and " are NOPs.

Python 2

First line is comment. Using integer division, calculates 4 - -int(-3 / 2) = 4 - -int(-2) = 4 - -(-2) = 4 - 2 = 2 and prints the result.

Python 3

Same as previous, but with float division. 4 - -int(-3 / 2) = 4 - -int(-1.5) = 4 - -(-1) = 4 - 1 = 3.

Lua

-- starts a comment, and # on the first line is a comment, so basically print(4).

><>

# reflects IP, 5 pushes 5, n prints a number and ; quits.

Befunge

# skips over the +, ! logically negates the top of the stack, "@\" pushes the string @\, 6 pushes 6, . prints a number and @ quits.

Pyth

# starts an infinite loop, dismissing any errors. 7 prints 7, then follows +!"string") which basically causes an error for not having two operands for +, terminating the program.

PurkkaKoodari

Posted 2015-12-03T13:20:41.150

Reputation: 16 699

JavaC++C, 363/27 = 13.4....

Java prints 1, C++ prints 2, C prints 3. Not breaking any records here (because Java), but I really like the clever, abusive way of making a polyglot in these languages that I discovered.

//\u000a/*
#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
//*/
/*\u002a/
import static java.lang.System.out;
public class P{//*/
/*\u002a/public static void//*/
main(/*\u002a/String[] args//*/
){//\u000a/*
out.print=p;
//\u002a/
out.print(1);}
/*\u002a/}//*/

This is a mess. Here's a breakdown of how it works. The Unicode literals (\u000a, otherwise known as a linefeed, and \u002a, otherwise known as *) are expanded by the Java compiler into their actual characters. So, here is what the Java compiler sees:

//
/*
#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
//*/
/**/
import static java.lang.System.out;
public class P{//*/
/**/public static void//*/
main(/**/String[] args//*/
){//
/*
out.print=p;
//*/
out.print(1);}
/**/}//*/

All that stuff in the beginning is ignored because it's all wrapped in a multi-line comment (/* ... */). Later on, we see that mixing single-line and multi-line comments allows us to control exactly which parts are commented out in each language. In the main method, we start a multi-line comment, and then have //*/. Ordinarily, this would be a single-line comment, but since we are in a multi-line comment, the // doesn't do anything, allowing the */ to close it.

This is the equivalent Java code, with comments removed:

import static java.lang.System.out;
public class P{
public static void
main(String[] args
){
out.print(1);}
}

Here is what the C/C++ compiler sees (I've removed the Unicode literals, since they are not expanded by the compiler and thus don't do anything):

///*
#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
//*/
/*/
import static java.lang.System.out;
public class P{//*/
/*/public static void//*/
main(/*/String[] args//*/
){//\/*
out.print=p;
///
out.print(1);}
/*/}//*/

Here, the single-line comments override the multi-line comment delimiters in the beginning, so all of the #defines and the #include get preprocessed. Next, multi-line comments are used to comment out the boiletplate code for Java. This is the equivalent code, with comments removed:

#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
main(
){
out.print=p;
out.print(1);}

A standard C/C++ polyglot trick (the #ifdef __cplusplus) is utilized to define a token o as either "2" or "3", depending on if it's a C++ or a C compiler that is compiling the code. Next, we define a funtion p that takes a single (ignored) int argument and calls printf, using our newly-defined o token. As per usual, the return value is left out, since we're not in strict mode. Next, we define a struct with a single member, a function pointer whose signature matches p's, and construct a single instance named out. In the main method (we leave off the int as usual), the address of p is assigned to out.print (so calling out.print calls p), and it is called.

If C++ wasn't included in the languages, we could drop all of the preprocessor code, and define p as int p(int a){puts("2");}. Unfortunately, C++ requires an #include to do I/O. If C wasn't included, we could drop the definition of p and the #ifdef preprocessor macro, and directly define a member function in the struct instead of needing a function pointer. Unfortunately, C does not support member functions.

Mego

Posted 2015-12-03T13:20:41.150

Reputation: 32 998

4 languages, 28 bytes / 64 = 0.4375

print((0 and 3^1or 1/2>0)+1)

1. Python 2

0 is falsy and / is integer division, so

(0 and 3^1 or 1/2 > 0) + 1 = (1/2 > 0) + 1 = (0 > 0) + 1 = False + 1 = 1

2. Perl (also Python 3)

0 is falsy and / is float division, so

(0 and 3^1 or 1/2 > 0) + 1 = (1/2 > 0) + 1 = (0.5 > 0) + 1 = 1 + 1 = 2

3. Ruby

0 is truthy and ^ is bitwise xor, so

(0 and 3^1 or 1/2 > 0) + 1 = xor(3,1) + 1 = 2 + 1 = 3

4. Lua

0 is truthy and ^ is exponentiation, so

(0 and 3^1 or 1/2 > 0) + 1 = pow(3,1) + 1 = 3 + 1 = 4

Note that Lua and Ruby can't add booleans as though they are integers, hence the grouping of them together. Unfortunately 0and doesn't work in Lua, so we can't save a byte there.

Previous 17 byte version which prints 1 (Lua), 2 (Ruby), 3 (Python/Perl):

print(2^(0 or 1))

-3 bytes thanks to @xnor for this version, making it a lot neater :)

Sp3000

Posted 2015-12-03T13:20:41.150

Reputation: 58 729

Would 2^(0 or 1) work? – xnor – 2015-12-07T11:09:48.987

@xnor Ah yes it would, thanks :) – Sp3000 – 2015-12-07T11:11:37.517

BFSRS><>funge93thon123, 73/343 ≈ 0.212827...

Brainfuck, Seriously, ><>, Befunge-93, Python 1, Python 2, Python 3

# 4['.]@kX21z-[>+<-----]>--.<;n3
import sys;print(3+int(sys.version[0]))

Contains unprintables, hexdump (reversible with xxd -ps -r):

2320345b272e5d406b5832317a7f2d5b3e2b3c2d2d2d2d2d5d3e2d2d2e3c
3b6e330a696d706f7274207379733b7072696e7428332b696e7428737973
2e76657273696f6e5b305d2929

I'll be adding more languages (and probably bytes) over time. Languages in the header are listed in order of what they print. Assumes 8-bit wrapping cells and a tape that won't complain about going left of the initial position (wrapping or infinite) for Brainfuck.

Brainfuck:

[.]   initial value of first cell is 0, so loop is skipped
-[>+<-----]>--  push 49 (ASCII ordinal of 1)
.     print "1"
<     move to blank cell
[0]   skip loop because cell is 0
      everything else is ignored

Seriously:

# 4['.]@  does some stuff we don't care about
kX        pop entire stack, push as list, discard (essentially the same as é, but is ASCII so we can use Python)
2         push 2
1z        pop 1 item from stack and print (used instead of . so Brainfuck doesn't print here; same as ü in this scenario, but is ASCII so we can use Python)
0x7f      terminate program
          everything else is ignored

><>:

#    mirror, reverse direction
3n;  push 3, print "3", end (reversed because IP is scanning RTL at this point)
     everything else is ignored

Befunge-93:

#     jump over the space
4['.] push 4, print 4 (brackets and ' do nothing)
@     end program
      everything else is ignored

Python 1 (thanks muddyfish):

# 4['.]@kX21z-[>+<-----]>--.<;n3         comment; ignored
import sys;print(4+int(sys.version[0]))  prints 4+1=5

Python 2:

# 4['.]@kX21z-[>+<-----]>--.<;n3         comment; ignored
import sys;print(4+int(sys.version[0]))  prints 4+2=6

Python 3:

# 4['.]@kX21z-[>+<-----]>--.<;n3         comment; ignored
import sys;print(4+int(sys.version[0]))  prints 4+3=7

Mego

Posted 2015-12-03T13:20:41.150

Reputation: 32 998

Python 1 also works. See http://codegolf.stackexchange.com/a/65652/32686. Doesn't add any chars (but change 3 to 4)

– Blue – 2015-12-04T19:01:49.617

14 languages, 73 bytes, score = (73/14^3) = 0.02660349854

#Y2(3`5n~thneo e        ;n@0d c
#   -[>+<"9"L-----]>+.
14  
print(int(15/2))+3

I can add some more langs, but I think I'll add what I have here.

1. Brainbool ; Try it online!

The relevant code:

    [>+<         ]>+.

               +

This is really just +.+, which outputs 1.

2. Jolf ; Try it here!

The ( char stops interpreting the source code, so the relavent code is:

#Y2

This is equivalent to (in JavaScript)

var Y = []; toHex(Y); alert(2);

Which outputs 2.

3. Element ; Try it online!

The relevant code:

3`

This captures 3 and prints it.

4. Brainfuck ; Try it online!

The relevant code is:

-[>+<    -----]>+.

  -    -      +

Which is the standard way of generating 4's char code and outputting it, and some other stuff after it.

5. Reng ; Try it here!

~ terminates the program, so the relevant code here is:

#Y2(3`5n~

# redefines Y to be the TOS, in this case, 0. 2 pushes 2; ( rotates the stack N times, popping N from the stack; 3` pushes -3; and finally, 5n prints 5.

6. ETA ; Try it online!

ETA only reads the letters E, T, A, O, I, N, S, H, so the code only executed is this:

       n thneo e         n     


  int int

Super-relevant code:

       n thneo

Or, equivalently: nthne o. n...e is a base-7 literal, and thn is the base-7 number for 54. o outputs this character. The submission errors out, but I don't know why.

7. Python 3

What it sees:

# comment
# comment
14
print(int(15/2))+3

15/2 yields 7.5, as / is float division. int(...) makes the number an int, which is then printed. The program errors out when +3 is encountered.

8. Julia

Julia sees:

# comment
# comment
14
print(int(15/2))+3

Instead of truncating 15/2, Julia rounds it up, yielding 8. It prints this, then errors out on encountering +3.

9. Fission ; Try it online!

Relevant code:

        <"9"L

I got this idea from Martin's Fission portion (more like stole it). L begins a left-facing thing, captures 9, and ends with <.

10. Whitespace ; Try it here!

The relevant code, translating spaces into S and tabs into T:

SSSTSTS
T
ST

It pushes 10 to the stack and outputs it as a number (T\nST).

11. Python 2

Python 2 sees this:

# comment
# comment
14
print(int(15/2))+3

(int(15/2))+3 is evaluated to be 11, and that's printed.

12. Gol><> ; Try it here!

Relevant code:

#                      ;n@0d c

This uses the trick used in Martin's answer that @ rotates different directions in ><> and Gol><>. # mirrors, c pushes 12, d pushes 13, 0 pushes 0, and @ brings c to the top of the stack, then being outted and printed with ;n.

13. ><> ; Try it online!

Relevant code:

#                      ;n@0d c

Again using that @ rotates different directions in ><> and Gol><>. # mirrors, c pushes 12, d pushes 13, 0 pushes 0, and @ brings d to the top of the stack, then being outted and printed with ;n.

14. Golfscript ; Try it online!

What it sees:

# comment
# comment
    14
print(-int(-15/2))+3

It pushes 14, prints it, and errors. ~~Stolen~~ inspired by Sp3000's answer.

Conor O'Brien

Posted 2015-12-03T13:20:41.150

Reputation: 36 228

Subskin, Brainfuck and Fob 27 bytes / 3^3 = 1

0#>&$3#<>$-[----->+<]>-.
31

Subskin

0
31

We set the instruction pointer (doesn't matter here) to 0 and the output register to 31. If the contents of the output register is >= 0, we output the contained value as a char. All other code is ignored.

Brainfuck

-[----->+<]>-.

Puts 3 in the register, decrements the value once with - and finally outputs with ..

Fob

#>&$3#<>$

This is a little bit more tricky, since Brainfuck also reads the < and > instructions in Fob. We enter execution mode with # and increment Brainfuck's pointer by one which makes it easier on us later. We have nothing to execute yet, so nothing is executed.

We enter the accumulator mode with $, throw in a 3, enter execution mode again, push the accumulator contents to the stack with < and finally we output the content with >.

To prevent Brainfuck from screwing with the program we enter accumulation mode again with $.

sweerpotato

Posted 2015-12-03T13:20:41.150

Reputation: 2 457

4 Languages (Befunge-93, Microscript II, Microscript, and Foo), score 7/64=0.109

"4"1.@2

Befunge: Push 4, push 1, print 1, and terminate.

Microscript II: Produce the string "4", discard it, take the square root of one, discard that, and finally set x to 2. This is then printed implicitly.

Microscript: Push 52 to the stack (which will never actually be used for the remainder of the program), increment the register (initially zero) by one, then increment the register by two. This is then printed implicitly.

Foo: Print the string "4", then push 2

SuperJedi224

Posted 2015-12-03T13:20:41.150

Reputation: 11 342

7 Languages, 55 / 7^3 ≈ 0.16035

Runs in PowerShell v1, v2, v3, v4, and v5, Foo, and Pyth

#7.q"6""
$p=$PSVersionTable;($p.PSVersion.Major,1)[!$p]

Digits 1-5 use similar logic to sweerpotato's answer. The $PSVersionTable special variable was introduced in PowerShell v2, and contains a full build list, revisions, etc. Here's an example output of the variable:

PS C:\Tools\Scripts> $PSVersionTable

Name                           Value                                                                                                                           
----                           -----                               
PSVersion                      4.0
WSManStackVersion              3.0
SerializationVersion           1.1.0.1
CLRVersion                     4.0.30319.34209
BuildVersion                   6.3.9600.17400
PSCompatibleVersions           {1.0, 2.0, 3.0, 4.0}
PSRemotingProtocolVersion      2.2

In this code, we first store it into $p so that the code length is shorter. Then, we check for its existence by leveraging the variable as an index into a two-item array:

If the variable doesn't exist, PowerShell will dynamically create it and assign it $NULL, the ! of which is $TRUE, or 1, which corresponds to the second element in the array, which outputs 1.
If the variable does exist (as is the case in v2+), then the ! of the variable results in $FALSE or 0, which indexes to the first element, which outputs the version number.

Using Foo for 6, we leverage that # is a comment in PowerShell, so that's ignored when executing it in a PS environment. However, Foo will happily spit out the number 6 and then proceed through the rest of the program, which does nothing.

Using Pyth for 7, we return 7, then immediately quit with .q, so the infinite while-true loop that started with # doesn't matter. Since we have something left that gets implicitly printed. Thanks to @FryAmTheEggman for this addition.

_{Edit - Golfed a handful of bytes thanks to Mauris} _{Edit - clarified Pyth explanation thanks to Sp3000}

AdmBorkBork

Posted 2015-12-03T13:20:41.150

Reputation: 41 581

How about $p=$PSVersionTable;($p.PSVersion.Major,1)[!$p]? That works on my Powershell, but maybe not on all previous versions. – Lynn – 2015-12-03T22:34:23.587

7 languages, 287 / 7^3 = 0.836

~~Probably the lowest score that gets in, anyway I like this 3 versions of C polyglot.~~

Added the boring Python solution to at least qualify for the "3 unique" languages bounty.

Added Java by abusing C trigraphs for different comment intepretations.

Works in:

Python 1
Python 2
Python 3
C89
C99
C++
Java

golfed version:

/*
*??/
/
#include <stdio.h>
#ifndef __cplusplus
#define true 8/*
import sys
print(sys.version[0])
'''
#*??/
/
#endif
int main(){int a=(true>1)?-6:3;printf("%d",(true//*
+a
//**??/
/+2));}
#define a \
'''
/**\u002f
public class p{public static void main(){System.out.println("7");}}
/**/

Ungolfed:

/*
*??/
/

#include <stdio.h>

#ifndef __cplusplus
#define true 8/*

import sys
print(sys.version[0])
'''
#*??/
/
#endif 

int main()
{
    int a = (true > 1) ? -6 : 3;
    printf ("%d", (true//*
    +a
    //**??/
/
    +2));
}
#define a \
'''

/**\u002f
public class p
{
    public static void main()
    {
        System.out.println("7");
    }
}
/**/

Ok this is probably getting kinda weired and I hope my english skills are good enough to explain it ordinary.

First of all I'll explain the different kinds of comments I used to encapsulate the language structures each for its own.

So lets take the first block:

/*
*??/
/

For Java this is just the beginning of an multi line comment. But... in C99/89/++ this evaluates to

/*
*/

Since ??/ is a trigraph for \ while in C the \ character is kind of consistent and even consumes line breaks in its commandfunctionality. This causes the result of an \n to be just "displayed" instead of beeing line breaks. that means, given this byte array representing the first block: [/][*][\n][*][?][?][/][\n][/] would be after trigraph evaluation: [/][*][\n][*][\][\n][/] Where the consistent functionality of the \ triggers and "consumes" the \n so the remaining and finaly in C langs evaluated bytes are: [/][*][\n][*][/]

But about all this java doesn't know anything and treats all that follows as an comment untill this trick gets reverted.

(to be continued!)

Zaibis

Posted 2015-12-03T13:20:41.150

Reputation: 1 663

Python 3, Ruby, Perl, C, C++, Objective-C 202 bytes / 6^3 = 0.935...

This was quite fun actually, and a lot of playing with booleans.

You can all versions of the code at the following site, by copy-and-pasting the code into the interpreter.

#include <stdio.h> /*
print ((("0"+"0"==0)and 3) or (0and 2or 1));
__DATA__ = 1
"""""
*/
int main(){putchar(
#ifdef __OBJC__
'6'
#else
#ifdef __cplusplus
'5'
#else
'4'
#endif
#endif
);return 0;}/*
"""
#*/

Python 3, prints `1`

The trick is the following:

print ((("0"+"0"==0)and 3) or (0and 2or 1));

This will print 1

Ruby, prints `2`

The interpreted code for Ruby is:

print ((("0"+"0"==0)and 3) or (0and 2or 1));

So this prints 2

Perl, prints `3`

The interpreted code for Perl is:

print ((("0"+"0"==0)and 3) or (0and 2or 1));
__DATA__ = 1

First of all, the __DATA__ token tells the Perl compiler that the compilation is finished. Everything after is ignored.

print ((("0"+"0"==0)and 3) or (0and 2or 1));

And prints 3

C, prints `4`

The interpreted code is quite different from the others:

#include <stdio.h>
int main(){putchar(
#ifdef __OBJC__
'6'
#else
#ifdef __cplusplus
'5'
#else
'4'
#endif
#endif
);return 0;}

This will simply print the char 4.

C++, prints `5`

The same as the C code

This will print the char 5.

Objective-C, prints `6`

The same as the C code

This will print the char 6.

Adnan

Posted 2015-12-03T13:20:41.150

Reputation: 41 965

Python 1|2|3, 27 bytes / 27 = 1

print(len("\xabc")+(1/2>0))

@sweerpotato's use of version numbers made me wonder whether it was possible to distinguish the Pythons in less. Here's the best I've found.

Explanation

To distinguish Python 3 from the earlier versions, we make use of the standard integer division vs. floating point division trick. (1/2>0) == (0>0) returns 0 pre-Python 2.3 or False from Python 2.3 onwards, and (1/2>0) == (0.5>0) returns True for Python 3.

To distinguish Python 1 from the rest, we take the length of the string "\xabc", which is length one in Python 1 and length two from Python 2 onwards. Why? Because

The \x escape in string literals now takes exactly 2 hex digits. Previously it would consume all the hex digits following the ‘x’ and take the lowest 8 bits of the result, so \x123456 was equivalent to \x56.

(From What's New in Python 2.0)

Sp3000

Posted 2015-12-03T13:20:41.150

Reputation: 58 729

Craneflak, Brain-Flak Classic, Rain-Flak, BrainHack, Brain-Flueue, miniflak, miniHack: .1020

(([]()()()<()()()>)()()){}#{}({}())

Explanation

The first thing going on here is that there is a difference in the way comments are read between the BrainHack, CraneFlak and Rain-Flak interpreters. Craneflak has no comments, in Rain-Flak # comments out the rest of the line and in BrainHack #{...} comments out the insides.

So here's what each language reads:

Rain-Flak: (([]()()()<()()()>)()()){}         -> 3
BrainHack: (([]()()()<()()()>)()()){}({}())   -> 4
Craneflak: (([]()()()<()()()>)()()){}{}({}()) -> 1

The next thing is the difference between the brain-flaks and the miniflaks. Both Rain-Flak and BrainHack support miniflak, where all of the extra operations are simply removed. This means that they lose the [] and <...>

Rain-Flak: (()()()()()())         -> 6
BrainHack: (()()()()()())({}())   -> 7

Next we have the difference between Brain-Flak and Brain-Flak Classic. In Classic [] is -1 instead of the stack height, which means that our result is 1 less than in regular Rain-Flak, making it 2.

Lastly we have the difference between brain-Flak and brain-flueue. In brain-flueue a queue is used instead of a stack. Normally brain-flak pushes 3 then 5 and pops the 5 away, however in brain-flueue the pop gets rid of the 3 and not the 5.

Post Rock Garf Hunter

Posted 2015-12-03T13:20:41.150

Reputation: 55 382

6 Languages, 38 / 6^3 = 0.17592̅5̅9̅

Whitespace, Brainfuck, Ruby, Labyrinth, Foo, Seriously

Legend:

£: tab

•: space

§: 0x7f

puts•2;#4!@•-[>+<-----]>6.§"5"•£    
£
•£

This contains unprintable characters, so here's the hexdump:

7075747320323b23342140202d5b3e2b3c2d2d2d2d2d5d3e362e7f22352220090a090a20090a

Explanation:

Whitespace

Try it online. (Note: my program omits the closing three linefeeds to terminate the program, I wrote/tested this on Whitelips and that produces the proper output there, but does not on Try It Online, so the linked program has those two characters added. As far as I can tell, some interpreters let you do that, others get stuck in an infinite loop without the explicit termination)

(omitting ignored characters)

spacespacespacetabenter: push a 1 onto the stack

tabenterspacetab: output the top of the stack

Ruby

Shouldn't need explaining. Prints 2, treats the rest of that line (ergo, the brainfuck program) as a comment, treats the rest of the file as empty.

Brainfuck

Requires an interpreter that supports underflow. Underflows the first cell to 255 then uses that for a loop counter to generate 51, which is the ascii code for 3.

Labyrinth

(omitting the last two lines for legibility because they are never reached)

puts•2;#4!@ -[>+<-----]>6.§"5"•£
puts•                            skipped
     2                           push 2 onto stack
      ;                          pop 2 from stack
       #                         push current stack depth (0) to stack
        4                        push 4 to stack
         !                       print top of stack as integer
          @                      program terminates

Foo

The only thing that affects output is "5", which prints 5.

Seriously

puts•2;#4!@ -[>+<-----]>6.§"5"•£
puts•2;#4!@ -[>+<-----]>           assorted stack manipulation that doesn't affect this program
                        6          push 6 to the stack
                         .         output top of the stack
                          §        (0x7f) terminate program

SnoringFrog

Posted 2015-12-03T13:20:41.150

Reputation: 1 709

5 languages, Chaîne, Minkolang, Foo, Brainf**k-ng, and Vitsy, 21 / 5^3 = 0.168

2|<«+!@"3".N+m

5N»

Brainf**k-ng

2|<«+!@"3".N+m

5N»
  <            go left (should still be ok)
    +!         output 1
      @        halt execution

Chaîne

2|<«+!@"3".N+m

5N»
2              «add 2 to the current string»
 |<            «take off and put on the string (no op)»
   «           «comment»

  »
               «implicit output»

Foo

2|<«+!@"3".N+m

5N»
       "3"     print three

Minkolang

2|<«+!@"3".N+m

5N»
2              C push 2 to the stack [2] C
 |             C mirror C
2              C push 2 to the stack [2,2] C
             m C ignored C
            +  C add top two [4] C
           N   C output C
          .    C terminate program C

Vitsy

2|<«+!@"3".N+m

5N»
2              push 2
 |             mirror
2              push 2
             m pop 2, goto line 2
5              push 5
 N             output 5
  »            ignored

I can probably add ><> or something.

Conor O'Brien

Posted 2015-12-03T13:20:41.150

Reputation: 36 228

1You know, I've never found a good use for mirror. xD – Addison Crump – 2015-12-04T23:47:02.167

5 Languages, 18 bytes / 5^3 = 0.144

Runs in Brainbool, Mathematica, Foo, ><> and Befunge-93.

4!<n;+Print@2"3".5

Brainbool

Brainbool is like Brainfuck, but it operates only on bits, and its input and output consists solely of 0 and 1.

4!<n;+Print@2"3".5
  <                   move the pointer to the left
     +                logic not
                .     print the current cell

Mathematica

In Mathematica, everything is an expression and has a value. Print@2 prints 2 and returns the symbol Null. After that, the code does some symbolic calculations, but doesn't print anything.

Foo

"3" prints 3. I don't know what the other parts do.

><>

4!<n;+Print@2"3".5
4                     push 4
 !                    skip the next command
   n                  pop and print it as a number
    ;                 end the program

Befunge

4!<n;+Print@2"3".5
4                     push 4
 !                    logical not
  <                   makes the program counter travel to the right
 !                    logical not
4                     push 4
                 5    push 5
                .     pop and print it as a number
             "3"      push the string "3"
            2         push 2
           @          end the program

12 Languages, 35 bytes / 12^3 = 0.0202546...

Using sweerpotato's trick, cheap but powerful.

Runs in Brainbool, Mathematica 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 and 10.0, Foo and ><>.

cn;+"11".Print@Floor@$VersionNumber

alephalpha

Posted 2015-12-03T13:20:41.150

Reputation: 23 988

Milky Way 1.0.2, CJam and STXTRM, 20 bytes / 3^3 = 0.741

I imagine there is at least one other language that I could add.

'2"3""1"1<<1>;;"2"3;

Explanation

Milky Way, `1`

In Milky Way, strings are only denoted by pairs of double quotes. A single quote reads input from the command line; if there is none, it pushes an empty string. Greater than and less than signs will rotate the entire stack rightward and leftward, respectively. Finally, a semicolon swaps the top two stack elements.

Here is a stack visualization (stack shown is the result of the listed operation after it has occurred):

["", 0]                                             #  default stack

["", 0, ""]                                 #   '   #  read input from command line
["", 0, "", 2]                              #   2   #  push 2 to the stack
["", 0, "", 2, "3"]                         #  "3"  #  push "3" to the stack
["", 0, "", 2, "3", "1"]                    #  "1"  #  push "1" to the stack
["", 0, "", 2, "3", "1", 1]                 #   1   #  push 1 to the stack
[0, "", 2, "3", "1", 1, ""]                 #   <   #  rotate the stack leftwards
["", 2, "3", "1", 1, "", 0]                 #   <   #  rotate the stack leftwards
["", 2, "3", "1", 1, "", 0, 1]              #   1   #  push 1 to the stack
[1, "", 2, "3", "1", 1, "", 0]              #   >   #  rotate the stack rightward
[1, "", 2, "3", "1", 1, 0, ""]              #   ;   #  swap the top two stack elements
[1, "", 2, "3", "1", 1, "", 0]              #   ;   #  swap the top two stack elements
[1, "", 2, "3", "1", 1, "", 0, "", 2]       #  "2"  #  push 2 to the stack
[1, "", 2, "3", "1", 1, "", 0, "", 2, "3"]  #   3   #  push "3" to the stack
[1, "", 2, "3", "1", 1, "", 0, "", "3", 2]  #   ;   #  swap the top two stack elements

CJam, `2`

In CJam, strings are also denoted by double quote pairs. A single quote pushes the character code of the following character. When a character code is output, it is output as its corresponding character. Greater-than and less-than signs act as expected, evaluating the order of the top two stack elements. Finally, a semicolon discards the top stack element. On termination of the program, the contents of the stack are output.

Here is a stack visualization (stack shown is the result of the listed operation after it has occurred):

[]                         #  default stack

['2]               #  '2   #  push the character code of "2" to the stack
['2, "3"]          #  "3"  #  push "3" to the stack
['2, "3", "1"]     #  "1"  #  push "1" to the stack
['2, "3", "1", 1]  #   1   #  push 1 to the stack
['2, "3", "1"]     #   <   #  leave the greater of the top two stack elements on the stack
['2, 0]            #   <   #  leave the greater of the top two stack elements on the stack
['2, 0, 1]         #   1   #  push 1 to the stack
['2, 1]            #   >   #  leave the lesser of the top two stack elements on the stack
['2]               #   ;   #  pop the top stack value
[]                 #   ;   #  pop the top stack value
['2]               #  "2"  #  push the character code of "2" to the stack
['2, "3"]          #   3   #  push "3" to the stack
['2]               #   ;   #  pop the top stack item

STXTRM, `3`

In MSM, anything that is not an operator is pushed to the stack as a character. A semicolon duplicates the top stack element. The program continues until there are no more operators, or there is a single element on the stack.

The final character on the stack is 3, which is duplicated by the final operator. 3 is the topmost element at the end of the program, so it is output.

Zach Gates

Posted 2015-12-03T13:20:41.150

Reputation: 6 152

5 languages, 18 bytes / 5^3 = 0.144

Ouroboros, Pip, QBasic, Foo, and Pyth

5'"4"()"
1?3'@n()2

1. Ouroboros

Each line of the program represents a snake eating its tail.

Snake 1

Push 5, ' is a no-op, push 52 (ASCII code of "4"). ( causes the snake to pop a number and eat that many characters of its tail. Since this results in swallowing the instruction pointer (and the entire snake), execution halts.

Snake 2

Push 1, push a random number (?), push 3, ' is a no-op. @ rotates the 1 to the top of the stack and n outputs it as a number, leaving the 3 on top of the stack. Then ( eats this many characters from the end of the snake, swallowing the instruction pointer and halting.

You can run this program online in the Stack Snippet interpreter here.

2. Pip

Most of the program consists of expressions which are evaluated and discarded:

5
'" (character literal)
4
"()"
1?3'@ (ternary expression)
n (variable, = newline)
() (nil)

Finally, the last expression, 2, is printed.

3. QBasic

Everything after ' is a comment. The first line thus boils down to 5, a line number. On the second line, 1 is a line number and ?3 is a shortcut for PRINT 3.

^{(Apparently having line numbers out of order isn't a problem, though it would be easy to fix if it were.)}

4. Foo

Almost everything is no-ops. "4" prints 4. The parentheses (x2) are a loop that runs until the current array cell is zero, which is true immediately and the loop exits. @, when not followed by a number, takes the value of the current array cell (initialized to 0) and pushes it to the stack.

I'm not entirely sure how the second, unmatched " is supposed to be handled. The online version seems to add a newline to the output, which the rules of the challenge allow.

5. Pyth

5 is output. Then the program encounters '"4", which tries to read from a file named 4. As long as no such file exists, I think this should terminate the program with an error. (The online version says name 'open' is not defined--I assume because opening files isn't allowed online.)

The stray " at the end of line 1 ensures that line 2 doesn't cause a syntax error before execution.

DLosc

Posted 2015-12-03T13:20:41.150

Reputation: 21 213

http://foo.tryitonline.net/#code=MT8zJ0BuIjQiKCky&input= – Dennis – 2016-04-21T04:12:30.290

@Dennis Thanks! The Esolangs page didn't have a link to that interpreter. – DLosc – 2016-04-21T04:30:53.177

Here's the index of the currently available languages. If you ever want me to add one, just ping me in chat.

– Dennis – 2016-04-21T04:34:34.563

4 languages, 24 bytes, 24/4^3=0.375

print(1//0.5--1+1/2*2
);

1. PHP

PHP executes print(1); which equals 1

2. Lua

Lua executes print(1//0.5); which equals 2

3. Python 2

Python 2 executes print(1//0.5--1+1/2*2); which equals 3 (integer division)

4. Python 3

Python 3 executes print(1//0.5--1+1/2*2); which equals 4 (float division)

penalosa

Posted 2015-12-03T13:20:41.150

Reputation: 505

Nice answer, I like answers in conventional languages :-) hope you'll have fun golfing on ppcg :-) please try out any of my previous challenges if you think they are interesting :-) some are a bit tricky and some are more basic :-) – Stewie Griffin – 2016-04-24T21:16:30.203

You might be interested in the open 100 rep bounty described in the challenge. Outgolf Sp3000 (28 bytes, 4 languages) using only conventional languages (defined in the link) and it's yours :-) unfortunately python 2 and 3 are not considered unique in the bounty challenge. – Stewie Griffin – 2016-04-24T21:22:32.907

Brainfuck-ng, Foo, ><>, 9 bytes / 3^3 = 0.333...

#+!"2";n3

Brainfuck-ng

The only characters it recognizes are + and !:

+ Increment cell by one
! Print as integer

Prints 1

Foo

Prints everything in quotes.

"2"

Prints 2

><>

# Mirrors the point to the left, 3 pushes 3 to the stack, n outputs it as an integer, ; stops the program.

#      ;n3

phase

Posted 2015-12-03T13:20:41.150

Reputation: 2 540

QBasic, QBIC and ><>, 18 bytes / 3^3 languages = 0.66666 points

1:?v+1'-5`
''`>3n;

Breakdown:

1. QBasic (Get the IDE)

1:          Line number 1
  ?         Print
   v+1      undefined var v = 0 + 1 = 1
'-5`        The rest of theis code is a QBasic comment
''`>3n;     As is this

2. QBIC (Get the interpreter)

1     inserts a 1 in the code - mostly harmless
:     Reads from the cmd line. Nothing there, creates an empty variable a
?     Print
v+1   v is initialised to 6, +1 = 7
'     Code Literal: everything till the ` is passed to QBasic without processing
 -5`  7-5 = 2

''`>3n; Code literal with the first literal being a ': comment in QBasic

3. ><> (Try it online)

1:  Push a 1 on the stack, duplicate stack
?   Pop top off the stack and skip next instruction if that's a 0
v   Move downwards - rest of the line is ignored

>   move to the right
3   Push 3 onto the stack
n   Print the top of the stack as a number
;   End the program

steenbergh

Posted 2015-12-03T13:20:41.150

Reputation: 7 772

1I think you want to cube the number of languages in your score (ie. 18 / (3^3) ) – math junkie – 2017-03-24T18:28:27.710

3 Languages, 82 83 / 3^3 = 3.074...

Works in ???, Whitespace, and Beatnik. Or rather, it should work in those languages but I am not going to be able to test them for a few days. Anyway, here is the code:

K... Jax... Jy... Jy...   ...
My...    My...
... ...     ......................XO!

1. ???

.................................................!

??? is basically brainfuck but it uses common punctuation as commands instead of the traditional characters. . increments the current memory cell, which is done 49 times. ! takes the current memory cell and prints it as a character, here 1.

2. Whitespace

[Space][Space][Space][Tab][Line Feed]
[Tab][Line Feed]
[Space][Tab]

Whitespace is a language that ignores all non-whitespace characters. Here I've converted it to an easily readable form. The first line pushes 2 onto the stack, and the second two lines print the top of the stack as a number, here 2.
Note that in the combined code, I have substituted tabs with four spaces due to technical limitations.

3. Beatnik

K Jax
Jy Jy
My My
XO

Beatnik is a language where each word is converted to its Scrabble score, then those scores are interpreted as commands. The first line pushes 17 onto the stack. The second line duplicates the top of the stack twice and the third line adds the top to elements of the stack together twice, effectively tripling 17 into 51. The last line prints the character on the top of the stack, here 3.
Note that I am using Beatnik at Face Value, assuming there is not an error in the original Beatnik specification. Also note that I am using the North American English Scrabble scoring system.

If it is not clear by now, each of these languages only accepts a certain type of character (punctuation, whitespace, and letters, respectively) so writing this polyglot was as easy as writing the individual programs. The only real "trick" is using the Whitespace code to separate the words from Beatnik. Beyond that, the individual programs do not overlap whatsoever.

Mike Bufardeci

Posted 2015-12-03T13:20:41.150

Reputation: 1 680

23^3=27 ==> 82 / 27 = 3.037037037037037... – AdmBorkBork – 2015-12-04T20:20:38.117

Your Whitespace code prints 0, not 2. Tested here and here.

– Dennis – 2015-12-05T05:40:25.323

@Dennis Thanks, I had omitted the sign bit. – Mike Bufardeci – 2015-12-05T16:55:59.047

5 languages, 175 / 5^3 = 1.4

I decided to post a different answer since the bounty is changing the requirements in a way that made me feel unsaitsfyed with my first answer (but which is still satisfying me in the way of the generall challange!)

So here is my solution that qualifys for the bounty challange:

It compiles in

C99
objC90
C++0x
Ruby
Perl

#if __cplusplus
#define x\
=begin\
=pod
#endif
int a=
#ifndef x
1//**/
+1
#else
3
#endif
;int main(){printf("%d",a);}
#ifdef f
=end
puts 5;
=begin
=cut
print"4";
=end
#endif

Zaibis

Posted 2015-12-03T13:20:41.150

Reputation: 1 663

3 languages, 15 bytes, score 0.555...

Gonna add more languages later.

2//1+1#

1. Emotinomicon

Emotinomicon pretty much ignores any text that isn't a string. pushes 1 to stack and outputs the TOS as a number.

2. Javascript

Comments in Javascript start with //, so only the 2 part gets executed.

3. Python 2/3 REPL

Comments in Python start with #, so only the 2//1+1 part gets executed. // is integer division in Python 3, and it is the same as / in Python 2. 2 divided by 1 is 2, plus 1 is 3.

acrolith

Posted 2015-12-03T13:20:41.150

Reputation: 3 728

4 languages, 97 bytes, 0.37890625

s="1";s=~-3;2//2;'''/.to_s.ord;"=;print 4;
__DATA__
=1;
";#'''#";print=s=>console.log(3)
print(s)

Ruby

This sets s to "1", compares using =~ against -3 in a void context, tries to divide 2 by /2;'''/.to_s.ord then starts a new string containing =;print 4; __DATA__ =1;, hits a comment, then prints s which is still 1.

Python

Sets s to "1" as per above, then sets it again to ~-3 which is 2. We run an integer division of 2//2, then there's a docstring containing /.to_s.ord;"=;print 4; __DATA__ =1; ";#, followed by a comment, finally printing s, which is still 2.

JavaScript

Sets s to "1" then sets it again to ~-3 as per above, then there's 2 on the line followed by a comment. Then we set the variable __DATA__ to 1. There's a short string containing ;#'''# followed by a definition of the function print which hardcodes the output to be 3, which is called on the next line.

Perl

Runs a substitution equivalent to s/"1";s/~-3;2\/\/2;'''\/.to_s.ord;"/, prints 4 and the rest of the string is masked behind the __DATA__ identifier.

Dom Hastings

Posted 2015-12-03T13:20:41.150

Reputation: 16 415

16 languages, 149 bytes, score 0.03637695312

1` FSR3U3%3&(()())#5➡MoOMoOMoOMoOMoOMoOOOM++++++++.$:H@@@@@@@.   {-   !*/}(10)aeeeaeeawaaaaaw> 11
➕⎚14»R"15"*
print 13
[ [

WIP, I plan to add a lot more.

Element
Brain-Flak
SimpleStack
Cubically
Emoji
COW
Agony (outputs via raw ASCII)
Beam
Commentator (currently broken but according to the language spec should work fine)
Straw
RProgN
Emotinomicon
S.I.L.O.S
Charcoal
Fission
evil

MD XF

Posted 2015-12-03T13:20:41.150

Reputation: 11 605

Jelly / 05AB1E / Whitespace, 14 bytes, score \$0.\overline{518}\$

[S][S][S][T][T][LF]
[T][LF]
[S][T]1o

[S], [T], and [LF] added for visual clarity only.

I was going to add naz to the chain, but I guess it doesn't handle whitespace very well.

Jelly explanation

[S][S][S][T][T][LF]
[T][LF]
[S][T]
1                   # Literal 1
 o
# ...after which the result is output implicitly

05AB1E explanation

[S][S][S][T][T][LF]
[T][LF]
[S][T]
1                   # Push 1
 o                  # Push 2 ** 1
# ...after which the result is output implicitly

Whitespace explanation

[S][S][S][T][T][LF] # Push 3 to the stack
[T][LF][S][T]       # Output the top of the stack
1o                  # Ignored

I'm not very good with these languages — if you spot anything wrong with these explanations, please feel free to improve this post!

sporeball

Posted 2015-12-03T13:20:41.150

Reputation: 461

JavaScript, HTML and PHP, 72 bytes / 3^3 = 2.67

1<!top?2:2//><!--<?='--'.'><script>document.body.innerHTML=3</script>'?>

In HTML, this will print the leading 1, ignore the <!window?2:2//> tag, and the rest is an HTML comment.

In JavaScript, it evaluates 1<!window?2:2 and outputs 2 (this must be run in a console) and the rest is a comment.

In PHP, the following is output from the server: 1<!top?2:2//><script>document.body.innerHTML=3</script> which replaces HTML's 1 with 3.

cuniculus

Posted 2015-12-03T13:20:41.150

Reputation: 265

Welcome to PPCG.SE! Great first post! Two things: we don't usually like REPL-based answers (the Javascript program). Additionally, the PHP code does not seem to run when I put it into an online interpreter, how exactly does the PHP work?

– GamrCorps – 2015-12-04T22:56:38.320

Thanks! Well, it's technically PHP + HTML (ie. if this is the source code for code.php, visiting http://site/code.php in a browser displays 3.

– cuniculus – 2015-12-05T00:21:06.407

Try it here: http://mowbl.com/se.php.

– cuniculus – 2015-12-05T00:23:07.247

Python 1,2,3, Pyth, Seriously 40 bytes/5^3 = 0.32

#4X.q5
import sys
print(sys.version[0])

Python 1,2,3 prints their version

This is based on the same code by sweerpotato. The # starts a comment so the first line is not compiled.

Pyth prints 4

#4X.q starts a while loop, X does something unnecessary, and .q quits the program.

Seriously prints 5

#4X.q5 starts out with # which does nothing, then 4 is pushed to the stack, X clears the stack, .q does nothing, and 5 is pushed on the stack and an invisible character (hex code 7f) quits the program and prints what is on the stack.

TanMath

Posted 2015-12-03T13:20:41.150

Reputation: 1 431

6 languages, 31 bytes, 31/6^3 = 0.1435

As soon as I add another language to it the score gets worse, here is what gave me the best result so far:

kill -l|wc|dc -e\?58%8/1+p#^[cc6

1-5: Various shells + dc

The shells see this, the rest of the line is a comment:

kill -l|wc|dc -e\?58%8/1+p

The shell's output for kill -L is different, their output gets piped to wc to count the number of bytes (N) and compute (N % 58)/8 + 1 which coincidentally gives the right result.

6: Vim

The key k doesn't do anything with the buffer, i switches to insert mode and the following characters get typed. After # there's an ^[ character so Vim switches back to normal mode. cc deletes the line and switches to insert mode where we insert 6.

Here's how it looks in Vim: