Before opening this I've done a little search and I've found there is a similar question, but it has been closed because it was ambiguous. I hope this won't.
So, your goal is to write a program that prints a number. The bigger is the number, the more points you'll get. But be careful! Code length is influent indeed. Your printed number will be divided for the number of bytes you used for your solution^3.
So, let's say you printed
10000000 and your code is
100 bytes long. Your final score will be
10 (1e1). Shortly, S=n/l^3 where S is the score, n is the number you printed and l is your code length (in bytes).
There are other rules to follow, in order to make this challenge a bit harder.
- You cannot use digits in your code (0123456789);
- You can use any language in which digits are valid characters (so that not using them is a real restriction);
- You can use mathematic/physic/etc. constants, but only if they are <10. (e.g. You can use Pi=3.14 but you can't use the Avogadro constant=6e23)
- Recursion is allowed but the generated number needs to be finite (so infinite is not accepted as a solution. Your program needs to terminate correctly and generate the requested output);
- You cannot use the operations *, /, ^ nor any other way to indicate them (e.g. 2 div 2 is not allowed);
- Your program can output more than one number, if you need it to do that. Only the highest one will count for scoring;
- You can concatenate strings: this means that any sequence of adjacent digits will be considered as a single number;
- Your code will be run as-is. This means that the end-user cannot edit any line of code, nor he can input a number or anything else;
- Maximum code length is 100 bytes;
Your program needs to terminate within 5 seconds.(Removed because golfers with faster computers would have been slightly advantaged).
- col6y, Python 3, ≈ (127→126→...→2→1) / 993 
- leftaroundabout, Haskell, ≈ g64 / 983 
- Toeofdoom, Haskell, ≈ a20(1) / 993 
- Fraxtil, dc, ≈ 15 ↑¹⁶⁶⁶⁶⁶⁵ 15 / 1003 
- Kendall Frey, ECMAScript 6, 10 3 ↑4 3 / 1003 
- Ilmari Karonen, GolfScript, ≈ 10 ↑3 10377 / 183 
- recursive, Python, 2↑↑11 / 953 ≈ 10↑↑8.63297 
- n.m., Haskell, 2↑↑7 / 1003 ≈ 10↑↑4.63297 
- David Yaw, C, ≈ 10104×1022 / 833 ≈ 10↑↑4.11821 
- primo, Perl, ≈ 10(12750684161!)5×227 / 1003 ≈ 10↑↑4.11369
- Art, C, ≈ 10102 × 106 / 983 ≈ 10↑↑3.80587
- Robert Sørlie, x86, 102219+32 / 1003 ≈ 10↑↑3.71585
- Tobia, APL, ≈ 1010353 / 1003 ≈ 10↑↑3.40616
- Darren Stone, C, 101097.61735 / 983 ≈ 10↑↑3.29875
- ecksemmess, C, ≈ 102320 / 1003 ≈ 10↑↑3.29749
- Adam Speight, vb.net, ≈ 105000×(264)4 / 1003 ≈ 10↑↑3.28039
- Joshua, bash, ≈ 101015 / 863 ≈ 10↑↑3.07282
- If every electron in the universe were a qubit, and every superposition thereof could be gainfully used to store information (which, as long as you don't actually need to know what's being stored is theoretically possible), this program requires more memory than could possibly exist, and therefore cannot be run - now, or at any conceiveable point in the future. If the author intended to print a value larger than ≈3↑↑3.28 all at once, this condition applies.
- This program requires more memory than currently exists, but not so much that it couldn't theoretically be stored on a meager number of qubits, and therefore a computer may one day exist which could run this program.
- All interpreters currently available issue a runtime error, or the program otherwise fails to execute as the author intended.
- Running this program will cause irreparable damage to your system.
Edit @primo: I've updated a portion of the scoreboard using a hopefully easier to compare notation, with decimals to denote the logarithmic distance to the next higher power. For example 10↑↑2.5 = 1010√10. I've also changed some scores if I believed to user's analysis to be faulty, feel free to dispute any of these.