Largest number in ten bytes of code

Question

Your goal is to print (to the standard output) the largest number possible, using just ten characters of code.

• You may use any features of your language, except built-in exponentiation functions.
  • Similarly, you may not use scientific notation to enter a number. (Thus, no 9e+99.)
• The program must print the number without any input from the user. Similarly, no reading from other files, or from the Web, and so on.
• Your program must calculate a single number and print it. You can not print a string, nor can you print the same digit thousands of times.
• You may exclude from the 10-character limit any code necessary to print anything. For example, in Python 2 which uses the print x syntax, you can use up to 16 characters for your program.
• The program must actually succeed in the output. If it takes longer than an hour to run on the fastest computer in the world, it's invalid.
• The output may be in any format (so you can print 999, 5e+100, etc.)
• Infinity is an abstract concept, not a number. So it's not a valid output.

Answer 1

Wolfram Language

ack(9!,9!)

ack(9!,9!) =

Output is in Arrow Notation.

Answer 2

Perl, >1.96835797883262e+18

time*time

Might not be the largest answer... today! But wait enough millennia and it will be!

---

Edit:

To address some of the comments, by "enough millenia," I do in fact mean n^100s of years.

To be fair, if the big freeze/heat death of the universe is how the universe will end (estimated to occur ~10¹⁰⁰ years), the "final" value would be ~10²¹⁴, which is certainly much less than some of the other responses (though, "random quantum fluctuations or quantum tunneling can produce another Big Bang in 10¹⁰⁵⁶ years"). If we take a more optimistic approach (e.g. a cyclic or multiverse model), then time will go on infinitely, and so some day in some universe, on some high-bit architecture, the answer would exceed some of the others.

On the other hand, as pointed out, time is indeed limited by the size of integer/long, so in reality something like ~0 would always produce a larger number than time (i.e. the max time supported by the architecture).

This wasn't the most serious answer, but I hope you guys enjoyed it!

Answer 3

Wolfram ≅ 2.003529930 × 10¹⁹⁷²⁸

Yes, it's a language! It drives the back-end of the popular Wolfram Alpha site. It's the only language I found where the Ackermann function is built-in and abbreviated to less than 6 characters.

In eight characters:

$ ack(4,2)

200352993...719156733

Or ≅ 2.003529930 × 10¹⁹⁷²⁸

ack(4,3), ack(5,2) etc. are much larger, but too large. ack(4,2) is probably the largest Ackermann number than can be completely calculated in under an hour.

Larger numbers are rendered in symbolic form, e.g.:

$ ack(4,3)

2↑²6 - 3 // using Knuth's up-arrow notation

The rules say any output format is allowed, so this might be valid. This is greater than 10^1019727, which is larger than any of the other entries here except for the repeated factorial.

However,

$ ack(9,9)

2↑⁷12 - 3

is larger than the repeated factorial. The largest number I can get in ten characters is:

$ ack(99,99)

2↑⁹⁷102 - 3

This is insanely huge, the Universe isn't big enough to represent a significant portion of its digits, even if you took repeated logs of the number.

Answer 4

Python2 shell, 3,010,301 digits

9<<9999999

Calculating the length: Python will append a "L" to these long numbers, so it reports 1 character more than the result has digits.

>>> len(repr( 9<<9999999 ))
3010302

First and last 20 digits:

40724177878623601356... ...96980669011241992192

Answer 5

CJam, 2 × 10^268,435,457

A28{_*}*K*

This computes b, defined as follows:

• a₀ = 10

• a_n = a_{n - 1}²

• b = 20 × a₂₈

$ time cjam <(echo 'A28{_*}*K*') | wc -c
Real    2573.28
User    2638.07
Sys     9.46
268435458

Background

This follows the same idea as Claudiu's answer, but it isn't based on it. I had a similar idea which I posted just a few minutes after he posted his, but I discarded it since it didn't come anywhere near the time limit.

However, aditsu's suggestion to upgrade to Java 8 and my idea of using powers of 10 allowed CJam to calculate numbers beyond the reach of GolfScript, which seems to be due to some bugs/limitations of Ruby's Bignum.

How it works

A    " Push 10.                                                          ";
28{  " Do the following 28 times:                                        ";
  _* " Duplicate the integer on the stack and multiply it with its copy. ";
}*   "                                                                   ";
K*   " Multiply the result by 20.                                        ";

---

CJam, ≈ 8.1 × 10^1,826,751

KK,{)*_*}/

Takes less than five minutes on my machine, so there's still room for improvement.

This computes a₂₀, defined as follows:

• a₀ = 20

• a_n = (n × a_{n - 1})²

How it works

KK,   " Push 20 [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ]. ";
{     " For each integer in the array:                                 ";
  )*  " Increment it and compute the its product with the accumulator. ";
  _*  " Multiply the result with itself.                               ";
}/

Answer 6

Python 3, 9*2^(7*2^33) > 10^18,100,795,813

9*2^(2^35) > 10^10,343,311,894

Edit: My new answer is:

9<<(7<<33)

Old answer, for posterity:

9<<(1<<35)

Ten characters exactly.

I am printing the number in hex, and

You may exclude from the 10-character limit any code necessary to print anything. For example, in Python 2 which uses the print x syntax, you can use up to 16 characters for your program.

Therefore, my actual code is:

print(hex(9<<(7<<33)))

Proof that it runs in the specified time and generates a number of the specified size:

time python bignum.py > bignumoutput.py

real    10m6.606s
user    1m19.183s
sys    0m59.171s
wc -c bignumoutput.py 
15032385541 bignumoutput.py

My number > 10^(15032385538*log(16)) > 10^18100795813

3 less hex digits than the above wc printout because of the initial 0x9.

Python 3 is necessary because in python 2, 7<<33 would be a long, and << doesn't take longs as inputs.

I can't use 9<<(1<<36) instead because:

Traceback (most recent call last):
  File "bignum.py", line 1, in <module>
    print(hex(9<<(1<<36)))
MemoryError

Thus, this is the largest possible number of the form a<<(b<<cd) printable on my computer.

In all likelihood, the fastest machine in the world has more memory than I do, so my alternate answer is:

9<<(9<<99)

9*2^(9*2^99) > 10^(1.7172038461*10^30)

However, my current answer is the largest anyone has submitted, so it's probably good enough. Also, this is all assuming bit-shifting is allowable. It appears to be, from the other answers using it.

Answer 7

Any language with short enough constant names, 18 digits approx.

99/sin(PI)

I would post this as a PHP answer but sadly M_PI makes this just a little too long! But PHP yields 8.0839634798317E+17 for this. Basically, it abuses the lack of absolute precision in PI :p

Answer 8

Haskell

Without any tricks:

main = print -- Necessary to print anything
    $9999*9999 -- 999890001

Arguably without calculating anything:

main = print
    $floor$1/0 -- 179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216

Adapting Niet's answer:

main = print
    $99/sin pi -- 8.083963479831708e17

Answer 9

Powershell - 1.12947668480335E+42

99PB*9E9PB

Multiplies 99 Pebibytes times 9,000,000,000 Pebibytes.

Answer 10

J (((((((((9)!)!)!)!)!)!)!)!)

Yeah, that's a lot. 10^(10^(10^(10^(10^(10^(10^(10^6.269498812196425))))))) to be not very exact.

!!!!!!!!9x

Answer 11

K/Kona: 8.977649e261 1.774896e308

*/1.6+!170

• !170 creates a vector of numbers from 0 to 169
• 1.6+ adds one to each element of the vector & converts to reals (range is 1.6 to 170.6)
• */ multiplies each element of the array together

If Kona supported quad precision, I could do */9.+!999 and get around 1e2584. Sadly, it doesn't and I'm capped to double precision.

---

old method

*/9.*9+!99

• !99 creates a vector of numbers from 0 to 98
• 9+ adds 9 to each element of the vector (now ranges 9 to 107)
• 9.* multiplies each element by 9.0 (implicitly converting to reals, so 81.0 through 963.0)
• */ multiplies each element of the vector together

Answer 12

HTML, 9999999999

9999999999

.. nailed it.

Answer 13

Python - Varies, up to 13916486568675240 (so far)

Not entirely serious but I thought it would be kinda fun.

print id(len)*99

Out of all the things I tried, len was most consistently getting me large ids.

Yielded 13916486568675240 (17 digits) on my computer and 13842722750490216 (also 17 digits) on this site. I suppose it's possible for this to give you as low as 0, but it could also go higher.

Answer 14

Golfscript, 1e+33,554,432

10{.*}25*

Computes 10 ^ (2 ^ 25), without using exponents, runs in 96 seconds:

$ time echo "10{.*}25*" | ruby golfscript.rb  > BIG10

real    1m36.733s
user    1m28.101s
sys     0m6.632s
$ wc -c BIG10
 33554434 BIG10
$ head -c 80 BIG10
10000000000000000000000000000000000000000000000000000000000000000000000000000000
$ tail -c 80 BIG10
0000000000000000000000000000000000000000000000000000000000000000000000000000000

It can compute up to 9 ^ (2 ^ 9999), if only given enough time, but incrementing the inner exponent by one makes it take ~triple the time, so the one hour limit will be reached pretty soon.

Explanation:

Using a previous version with the same idea:

8{.*}25*

Breaking it down:

8         # push 8 to the stack
{...}25*  # run the given block 25 times

The stack at the start of each block consists of one number, the current number. This starts off as 8. Then:

.         # duplicate the top of the stack, stack is now | 8 | 8 |
*         # multiply top two numbers, stack is now       | 64 |

So the stack, step by step, looks like this:

8
8 8
64
64 64
4096
4096 4096
16777216
16777216 16777216

... etc. Written in math notation the progression is:

n=0, 8                     = 8^1  = 8^(2^0)
n=1, 8*8                   = 8^2  = 8^(2^1)
n=2, (8^2)*(8^2) = (8^2)^2 = 8^4  = 8^(2^2)
n=3,               (8^4)^2 = 8^8  = 8^(2^3)
n=4,               (8^8)^2 = 8^16 = 8^(2^4)

Answer 15

wxMaxima ~3x10^49,948 (or 10^{8,565,705,514} )

999*13511!

Output is

269146071053904674084357808139[49888 digits]000000000000000000000000000000

---

Not sure if it quite fits specs (particularly the output format one), but I can hit even larger:

bfloat(99999999!)

Output is

9.9046265792229937372808210723818b8565705513

That's roughly 10^{8,565,705,514} which is significantly larger than most of the top answers and was computed in about 2 seconds. The bfloat function gives arbitrary precision.

Answer 16

Haskell, 4950

Aww man, that's not a lot! 10 characters start after the dollar sign.

main=putStr.show$sum[1..99]

Answer 17

Mathematica, 2.174188391646043*10^20686623745

$MaxNumber

Ten characters exactly.

Answer 18

Python shell, 649539 999890001

Beats Haskell, not really a serious answer.

99999*9999

Answer 19

Wolfram Alpha (does a website count as a language)?

9! ! ! ! !

outputs

10^(10^(10^(10^(10^(6.27...))))

thanks to Cory for the tip that spaces work as well as parens.

Answer 20

I'd rather post this as a comment above, but apparently I can't since I'm a noob.

Python:

9<<(2<<29)

I'd go with a larger bit shift, but Python seems to want the right operand of a shift to be a non-long integer. I think this gets closer to the theoretical max:

9<<(7<<27)

The only problem with these is that they might not satisfy rule 5.

Answer 21

Befunge-93 (1,853,020,188,851,841)

Glad nobody has done Befunge yet (it's my niche), but dammit I can't find any clever trick to increase the number.

9:*:*:*:*.

So it's 9^16.

:*

Basically multiplies the value at the top of the stack with itself. So, value at the top of the stack goes:

9
81
6561
43046721
1853020188851841

and

.

Outputs the final value. I would be interested to see if anybody has any better ideas.

Answer 22

At least Python 3.5.0 (64-bit), more than 10^242944768872896860

print("{:x}".format( 9<<(7<<60) ))

In an ideal world, this would be 9<<(1<<63)-1, but there aren't enough bytes for that. This number is so big that it requires almost 1 EiB of memory to hold it, which is a little bit more than I have on my computer. Luckily, you only need to use around 0.2% of the world's storage space as swap to hold it. The value in binary is 1001 followed by 8070450532247928832 zeros.

If Python comes out for 128-bit machines, the maximum would be 9<<(9<<99), which requires less than 1 MiYiB of memory. This is good, because you'd have enough addressable space left to store the Python interpreter and the operating system.

Answer 23

Cubix, 9.670457478596419e+147 (non-competing)

****"///**

Non-competing because Cubix is newer than this challenge. You can test it online here, but note that it doesn't actually print the number; you'll have to pause the program after the last two *s are run to see the value on the stack.

How it works

Cubix is a 2-dimensional esolang where the code is wrapped around a cube. This code is exactly equivalent to the following cube net, where . is a no-op:

    * *
    * *
" / / / * * . .
. . . . . . . .
    . .
    . .

Then the code is run, with the instruction pointer (IP) starting on the top-left corner of the leftmost face, facing right. " turns on string mode, where all chars encountered until the next " push their char-codes to the stack. The IP wraps all the way around the code, pushing three /s (47), two *s (42), and two .s (46) to the stack, before exiting string mode again.

Here's where it gets interesting. The first mirror / reflects the IP so it's facing up; it then rotates around the cube, hitting these chars:

           
    * *
  /     *      
  .     .      
    . .

The three *s multiply the top two items on the stack. Now, unlike most stack-based languages where arithmetic operators pop their arguments, Cubix leaves the previous values on the stack. So that means this calculates 46*46 = 2116, 46*2116 = 97336, 2116*97336 = 205962976.

When the IP reaches the / again, it is turned right. It then hits the next mirror and follows this path:

    *  
    *  
    /         .
    .         .
    .  
    .  

The two asterisks multiply the top two items once more. Then the mirror directs the IP right again, and the third mirror repeats the process once more:

      *
      *
      /     .  
      .     .  
      .
      .

Finally, the IP leaves the mirror section heading east. The two finaly asterisks multiply two more times, leaving a result of 9.670457478596419e+147 on the stack. This could be printed with O, but there's no easy way to do that since practically every spot on the cube is already used.

Answer 24

Casio fx-350 ES PLUS, approx. 9.999882753E99

Do calculators count?

At 70! the calculator throws error because apparently it has a number range limit -1E100 ~ 1E100

Answer 25

Matlab (1.7977e+308)

Matlab stores the value of the largest (double-precision) floating-point number in a variable called realmax. Invoking it in the command window (or at the command line) prints its value:

>> realmax

ans =

  1.7977e+308

Answer 26

Python, ca. 1.26e1388

9<<(9<<9L)

Gives:

126026689735396303510997749074166929355794746000200933374690887068497279540873057344588851620847941756785436041299246554387020554314993586209922882758661017328592694996553929727854519472712351667110666886882465827559219102188617052626543482184096111723688960246772278895906137468458526847698371976335253039032584064081316325315024075215490091797774136739726784527496550151562519394683964055278594282441271759517280448036277054137000457520739972045586784011500204742714066662771580606558510783929300569401828194357569630085253502717648498118383356859371345327180116960300442655802073660515692068448059163472438726337412639721611668963365329274524683795898803515844109273846119396045513151325096835254352967440214290024900894106148249792936857620252669314267990625341054382109413982209048217613474462366099211988610838771890047771108303025697073942786800963584597671865634957073868371020540520001351340594968828107972114104065730887195267530118107925564666923847891177478488560095588773415349153603883278280369727904581288187557648454461776700257309873313090202541988023337650601111667962042284633452143391122583377206859791047448706336804001357517229485133041918063698840034398827807588137953763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L

Answer 27

Aceto

kτ\p******u

Prints out

1 * 10⁸⁴⁶ (2017)

1.1 * 10⁸⁴⁶ (2018)

1.3 * 10⁸⁴⁶ (2019)

6.89 * 10¹³⁵³⁷ (2019)

Explanation

k - makes the stack 'sticky' so that values when popped are only copied,
 not removed
τ - pushes the date on the stack (the year is on the top, 2017 right now...)
\ - escapes the next character (print)
p - (ignored on first go-around)
*
 *
  *
   *        Multiplies top element by second, but stack has one element so it does it by itself
    *
     *
      *
       *
u - reverses instruction pointer direction
       *
      *
     *
    *
   *
  *
 *
*
p - prints
\ - escapes the date
k - makes stack sticky

Try it online!

Answer 28

Perl, non competing

I'm using this to highlight a little know corner of perl.

Perl can't really compete on this one because it doesn't have builtin bignums (of course you could load a bignum library).

But what everybody knows isn't completely true. One core function actually can handle big numbers.

The pack format w can actually convert any size natural number between base 10 and base 128. The base 128 integer is however represented as string bytes. The bitstring xxxxxxxyyyyyyyzzzzzzz become the bytes: 1xxxxxxx 1yyyyyyy 0zzzzzzz (every byte starts with 1 except the last one). And you can convert such a string to base 10 with unpack. So you can write code like:

unpack w,~A x 4**4 .A

which gives:

17440148077784539048602210552864286760481312243331966651657423831944908597692986131110771184688683631223604950868378426010091037391551287028966465246275171764867964902846884403624214574779667949236313638077978794791039372380746518407204456880869394123452212674801443116750853569815557532270825838757922217314748231826241930826238846175896997055564919425918463307658663171965135057749089077388054942032051553760309927468850847772989423963904144861205988704398838295854027686335454023567793114837657233481456867922127891951274737700618284015425

You can replace the 4**4 by larger values until you feel it takes too long or uses too much memory.

Unfortunately this is way too long for the limit of this challenge, and you can argue that the base 10 result is converted to a string before it becomes the result so the expression doesn't really produce a number. But internally perl really does the needed arithmetic to convert the input to base 10 which I always considered rather neat.

Answer 29

TI-36 (not 84, 36), 10 bytes, approx. 9.999985426E99

Older calculators can be programmed to an extent as well ;)

69!58.4376

This is very close to the maximum range a TI calculator can display: -1E100<x<1E100

Answer 30

Perl 6, 456,574 digits

[*] 1..ↈ

No TIO because it takes 2 minutes to run.

Answer 31

Keg, 260144641↑260144641

*:*(:|:*

Surprised I was able to get it this high, probably can be improved

Edit: Improved by A__

How it works

   Pushes 127 to the stack twice, I used 127 since it is the highest number that can be pushed in 1 byte (Note there is two characters there, they're just unprintables)
*    Multiplies them
:*   Squares that
(    Begin a for loop
:|   That will run 260144641 times (since that is the top element of the stack)
:*   That squares the top element of the stack
At the end it will automatically get printed

Answer 32

Scala, 2⁶³-1

Poor, poor Scala. Takes at least 8 characters to get a BigInt value, which doesn't leave enough room to actually make it big.

But with only 7 characters of (counted) code, we can print the largest possible positive Long:

print(-1L>>>1)

Answer 33

Brainf**k 256 - 2147483647

>+[<+>+]<.

_{If you ignore the fact that most compilers & interpreters output data as it's ascii equivalent (be leanient, it is what it is ;) )}, this will return the maximum value of the interpreter/compiler's datatype.

On some systems this is just 256, although on some (mine for example), this is the max value of a 32 bit integer, ie 2 147 483 647.

Edit:

-.

Will print the same thing in many fewer characters

Answer 34

Brain-Flak, 100 (non-competing)

(()@lt99)

Note that this code must be run with the -d flag which adds 3 bytes.

Try it online!

This uses the @lt debug flag in the ruby interpreter. This flag simply adds the following number to the value which is then pushed by the enclosing parentheses.

The enclosing parentheses do not modify the number and are required for it to be printed so they are not counted towards then 10 bytes.

The () adds one to the value and causes the interpreter to recognize the enclosing parentheses as pushing a value (parentheses will only push a value if they enclose non-debug flag Brain-Flak code.

Answer 35

Braingolf, I don't even know [non-competing]

#~U&^^^^^^

Doesn't work on TIO as I need to get Dennis to pull, but as you can see here, U in Braingolf calculates a range from 1 to the last item on the stack, in this case ~ or 126

Then reduces the entire stack with exponentiation, meaning the stack now contains 1 value which is equal to 126^125^124...^2^1

We'll call this value n from now on.

Then I had some bytes left, so I filled them with some monadic ^ operators.

This means the final output is (((((n^n)^n)^n)^n)^n)

For reference, 126^125 is 3.518180682714907e+262 and (126^125)^124 is ~35000 digits long

Answer 36

APL (Dyalog) — largest representable number (only 3 bytes)

This is the minimum reduction of an empty list:

⌊/⍬

⌊ minimum

/ reduction

⍬ empty list

When reducing an empty list, APL will return the identity element of the function used (if known). For minimum reduction of a system without infinities (e.g. ISO APL, to which Dyalog APL adheres), the identity element for minimum is the largest representable number:

Try it online! (IEEE 754 64-bit floating-point)

Try it online! (IEEE 754-2008 128-bit decimal floating-point)

Answer 37

Tcl, number in the Demo Output because it is very extense (has 30104 digits)

namespace path tcl::mathop
puts [<< 9 99999]

The relevant part is

<< 9 99999

, the rest is boilerplate.

Try it online!

Answer 38

Pyt, (only 6 bytes)

9!ḞɳƖ*

Try it online!

Link to number

I don't really see any point in getting any bigger than this. Anything else exceeds the runtime limit on TIO

9  pushes 9
!  factorial of 9 (362880)
Ḟ  push xth Fibonacci Number (really big)
ɳ  push 0123456789
₫  reverse ("987654321")
Ɩ  cast to int ("987654321")
*  multiplies

Answer 39

Runic

This answer is only works, if the following things are true:

1. I implement the Ackermann function using a non stack overflowing implementation.
   • Which I did briefly last night, but removed as there is no useful reason to keep it
   • It did successfully calculate Ack(4,3) over the course of 20-30 seconds, a number with 19729 digits.
2. If there are no arbitrary execution limits (e.g. TIO's 60 second timeout)
3. The executing computer has an arbitrary amount of memory to store exceedingly large stacks of BigIntegers

But if given those, then this program...

'ÿY:A:A:A@

...prints a number so large simply calculating how many digits it has is impossible, due to the explosive nature of the Ackermann sequence. Heck the inputs to the first call are both 255000!

The output (and thus input to the next call) is (in Knuth up-arrow notation): 2 ↑^254998255003 - 3
(that's 254 BILLION arrows!)

Explanation

>                Implicit entry
 'ÿ              Pushes the character ÿ onto the stack (which will be implicitly converted to an `int`
                    whenever a math operator is called on it).
   Y             Multiply by 1000 (the 'biggest' thing we can apply to a single stack value in 1 byte) 
    :            Duplicate top item on the stack
     A           Pop x and y, call Ack(x,y)
      :          Duplicate top item on the stack
       A         Pop x and y, call Ack(x,y)
        :        Duplicate top item on the stack
         A       Pop x and y, call Ack(x,y)
          @      Print the entire stack, top to bottom (there's only 1 value) and terminate

Larger still?

`AAAAAAAA@

Push the character sequence A,A,A,A,A,A,A,A,@ onto the stack (9 items) as the instruction pointer begins a character sequence on ` and loops around until it sees ` again. Each A then invokes Ack(x,y) (where x is the top of the stack) until the stack contains 1 entry, printing it. Not sure if this is actually larger or not.

However...

The closest we can get by abiding by the limitations is this:

':pba,*@

(Note the non-printing character 0x8F in position 2)

Try it online!

Which prints 1.79657789596691E+308 (143¹⁴³ * 1.1). The multiplier of 1.1 is the largest that can be applied without rolling over to infinity due to the limits on a double: even multiplying by a9, (1.11) is sufficient to trigger the infinity bit.

Answer 40

Perl 6, 730 quadrillion digits

9+<now*now

This builds the Perl 5 solution (time*time) and the Javascript (bit shifting). Time is currently around 1.56 billion, so we square it (~2.44 quintillion), and then bitshift 9 (because > 1 ha) a fairly insane number of digits to the right. Perl 6 uses arbitrary precision integers, and that applies to bitshifting as well. Bit shifting in and of itself doesn't take hardly any time at all, it's just a question of memory restraint and the largest super computers ought to have sufficient, but I don't on my puny laptop.

Given 2^10x ≈ 10^3x, we can surmise that there should be around some 730 quadrillion digits if I did my math right. Times out on TIO for 9+<$x where $x > 1000000, but handles 100000 in sub 1 secs ao no TIO link. Answer of course will continue to grow exponentially

(if that's considered out of bounds, though, can just make it 9+<now which should still fetch a fairly high number, or any other technique to generate the largest in-bounds number at in 7 digits)

Answer 41

Keg, 1.85302E+15

It is definitely the worst answer here...

9:*:*:*:*.

Answer 42

BBC BASIC 2

7 bytes

P.2^127

Result

1.70141181E38

As commented the previous answer may violate the exponation rule, so here's something using the EXP (exponent) function instead.

P.EXP(88)

which returns

1.65163622E38

Answer 43

Perl, 1.84467422290351e+26 (On a 64-bit machine)

perl -le "print ~0*9999999"

Answer 44

Python 2.7 - 8794643931199480236 15616093818140822

print hash('zz')

Answer 45

JavaScript, more than 13 003 624 633 896 (but it reads a clock)

9*new Date

Reading from a clock is effectively taking an input. Feels like cheating. However, the technique seems to be well-received in the answers here.

If clocks are not allowed, then:

JavaScript, 186 025 771 008

99*(7<<28)

Trigonometry takes too many bytes (Math.sin, Math.PI).

Bit-shift goes near the integer maximum, then multiplication yields a floating point.

Answer 46

C++ prints 18446744073709551615

#

ULLONG_MAX is 10 characters.

#include <iostream>
#include <limits.h>
using namespace std;
int main()
{
cout<<ULLONG_MAX<<endl;
return 0;
}

Answer 47

TXR:

$ txr -p '(mask 999)'
535754303593133660474212524530000905280702405852766803721875194185175525562468061246
599189407847929063797336458776573412593572642846157810728751889829846429852761096554
990320661140395677219337642394922319490470301292036210344653556258987007434741839952
7286296858625998634149561158533358569939198279680

Answer 48

Bash / shell

You may exclude from the 10-character limit any code necessary to print anything.

... you can use up to 16 characters for your program.

(6 chars for code + 7 chars for printing = 26 digits) = 6888888 digits

$ seq -s9 999999

---

This number is bigger, but people may argue that it's in the wrong format.

The output may be in any format (so you can print 999, 5e+100, etc.).

(8 chars for code + 8 chars for printing = 26 digits) = more than 1183888008 digits

$ seq -s9 99999999

It usually takes around a minute to print the number and it contains the scientific representation of it.

---

Some funny example:

(10 chars = 26 digits)

echo $$$$$$$$$$
2760127601276012760127601

See: What does $$ mean in the shell?

Answer 49

Perl: 6.27710173538668e+57 on cygwin with a Perl 32 bit

perl -e 'print ~0*~0*~0, "\n"'

Answer 50

Ozone, 9e+90000

(1)n1n1s2

Though it depends on dialect.

Answer 51

><>, 3147440830160257032480100000000 319626579315078487616775634918212890625

Edit:

Seems like I am allowed to exclude the characters needed for printing, the n in this case, so here is an updated version:

':*:*:*:*nÿ

Original answer:

'*:*:*:*n;

Here, ' activates stringmode, and pushes all the following characters to the stack, before wrapping and exiting stringmode. Then it does a multiply-and-copy chain, printing the number, and exits. Of interest here is the ascii value of n 110, and ; 59.

However, if we allow it to terminate with an error, we can abuse the fact that the official interpreter supports Unicode. The title of the question says bytes, but the text says characters, so the following program is just for the fun of it.

'*:*:*:*n

Outputting 1867215243681462552708446358738678532523702556144100000000

Alternatively, to stick to bytes, ÿ at the end gives us 383233022803952503175039062500000000, and that is still nice.

(New "for fun" program ':*:*:*:*n prints 7587624076546380447593767884781979512738274729546264306618287972087303430335365121)

Answer 52

SmileBASIC, 8,589,934,592 274,877,906,944

?#RED*#RED

#RED is a constant for the color red (&HFFF80000)

The expression only takes up 9 characters, so I can print it in 10 characters without decreasing the number.

Answer 53

Befunge-93, ~2.49e+40

"**:*:*:*.

This works by pushing the ASCII values of the program onto the stack and doing a bunch of multiplication.

Unfortunately, this doesn't work in TIO, but it does in this interpreter.

Here is a worse version that actually works in TIO:

"$$**:*:*.

And prints 1152921504606846976. TIO ended up pushing a lot of spaces and 2 zeroes at the end, so I had to get rid of those.

Note that both of these programs print the number forever, because the end command (@) would have taken up a precious byte.

Answer 54

Wolfram

999999999!

Result:

9.90462657922299373728082110506570432171722139002... × 10^8565705513

Eight and a half billion digits!

This is the biggest I could find without using a named function such as "ack()".

Answer 55

PHP , 11 bytes 1.9662705e+77

<?=9**9**9;

Answer 56

Acc!!, 999999

19*3
Write _
Write _
Write _
Write _
Write _
Write _

As any code necessary to output anything is excluded, all 'Write ' statements are excluded.

Try it online!

Answer 57

PHP, 9 bytes, MAX INT (9223372036854775807)

echo ~0^1<<63;

or

echo -1^1<<63;

Set an int of all bits on (-1) then XOR it with an int of only the first bit on to flip the sign bit.

Answer 58

Stacked, 10 bytes ~ 2 × 10²⁷³⁹⁶⁴

17932!:*:*

Try it online! Snippet outputs the length, then the number itself.

This calculates (17932!)⁴ (without exponentiation) using scientific precision, so only a constant width is perpetuated. The number looks like:

204449781735459736090000000000000000...00000000000000000

This Wolfram|Alpha link shows what the precise calculation would look like.

Answer 59

x86_64 machine language (Linux) ~2.808896e+307

0:       f2 0f 10 05 fa ff ff    movsd  -0x6(%rip),%xmm0        # 2
7:       ff 
8:       c3                      retq   
9:       7f

This moves the IEEE-754 double precision float 7f c3 ff ff ff fa 05 10 to %xmm0 and returns.

Try it online!

Answer 60

Javascript (ES6), 4E+30103

9n<<99999n

Uses big integers so actually goes way past what normal integers could reach.

Answer 61

C (gcc), 9 * 10^4202512

printf("9%.*u",""); or printf("9%0*u","");

Try it online!

The shortest way to print anything in C (afaik) is puts(""); which is 9 bytes
19 - 9 = 10

.* specifies precision which isn't exponentiation

.number

For integer specifiers (d, i, o, u, x, X) − precision specifies the minimum number of digits to be written. If the value to be written is shorter than this number, the result is padded with leading zeros. The value is not truncated even if the result is longer. A precision of 0 means that no character is written for the value 0. For e, E and f specifiers − this is the number of digits to be printed after the decimal point. For g and G specifiers − This is the maximum number of significant digits to be printed. For s − this is the maximum number of characters to be printed. By default all characters are printed until the ending null character is encountered. For c type − it has no effect. When no precision is specified, the default is 1. If the period is specified without an explicit value for precision, 0 is assumed.

https://www.tutorialspoint.com/c_standard_library/c_function_printf

So you'll get 9 followed by "" digits,(4202512)
the very last ones read from memory as the number to print is not specified,
adding ,0 would prevent memory reading but push it over the 10 byte limit

Answer 62

33, 7,762,279,691,451,941,920

999999axxao

I'm trying to get the language on TIO

About 7.76227969 x 10¹⁸

Answer 63

Forth (gforth), 9 bytes, 7 bytes

-1. ud.

Try it online!

Produces: 340282366920938463463374607431768211455

Answer 64

MathGolf, \$\approx 1.609 \times 10^{1859933}\$

9!!

Try it online!

With MathGolf being a language written in Python, the main issue will be calculating the number in a timely fashion. This program produces its output in about a minute. It might be possible to to \$(10!)!\$, which would be significantly bigger. However, the approach and the byte-count is still the same.

Answer 65

Wolfram Alpha (click)

fib(99999)

= 1.60528...e20898.

Answer 66

CJam - 40.4 million digits

1X27m<m<

Assuming bit shift is ok, this calculates 1<<(1<<27). It takes about 15 minutes on my laptop, using java 8 to run the interpreter.

Answer 67

units interactive shell, 3.085369e+68

You read that right, I know it's not much but it's definitely different.

9999Ypc
ym

I'm assuming newline counts as a character and the invocation of units counts as code essential to print. Ypc is yotta parsec, ym is yocto meter.

You have: 9999Ypc
You want: ym
    * 3.085369e+68
    / 3.2411034e-69

Answer 68

C#: 1.8E+19

Unfortunately we can't bit-shift doubles.

using System;
namespace BigNum10Bytes
{
    class Program
    {
        static void Main()
        {
            // Playing with ulongs 
            Console.WriteLine(ulong.MaxValue);
            Console.WriteLine(~(1UL<<64)); // 10 chars, 18446744073709551614
            Console.WriteLine(8191UL<<51); // 10 chars, 18444492273895866368

            Console.ReadLine();
        }
    }
}

Answer 69

Cjam - alot

alot:

99999999m!

even more:

9999999,m!

Unfortunately i cant calculate the result. But refering to wikipedia 14842907m! would be 2.788662975×10 ^ 100 000 000