Perl, >1.96835797883262e+18

time*time

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

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!

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.                               ";
}/

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

Python 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

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.

As large as it is, Graham's number surpasses anything expressible as an Ackermann number.

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

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

!!!!!!!!9x

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

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.

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)

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

My number is:

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<<(1<<35)))

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

$ time python bignum.py > bignumoutput.py 

real    2m27.213s
user    0m38.001s
sys    0m13.572s
$ wc -c bignumoutput.py 
8589934597 bignumoutput.py

Greater than 10^(8589934594*log(16))=10^10,343,311,894

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

I can't use 9*2^(2^36)) instead because:

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

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.

Powershell - 1.25371912013172E+35

99PB*999PB

Multiplies 99 Petabytes times 999 Petabytes.

Haskell, 4950

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

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

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

Python shell, 649539 999890001

Beats Haskell, not really a serious answer.

99999*9999

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.

JavaScript, 12624366232773, conditional on the legality of clock-reading

9*new Date

I don't think we should be allowed to refer to the clock for this, since it's essentially taking an input. However, the technique seems to be well-received here.

If clocks are not allowed, then:

JavaScript, 186025771008

99*(7<<28)

With printing:

console.log(99*(7<<28))

Can't use any trigonometry without feeding bytes to something like Math.sin, and Math.PI.

Odd that this code might work in many different languages. This answer is particular to JS because it uses bit-shift to go near the integer maximum, then multiplies to get a floating point.

Mathematica, 2.174188391646043*10^20686623745

$MaxNumber

Ten characters exactly.

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.

TXR:

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

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?

Python 2.7 - 8794643931199480236 15616093818140822

print hash('zz')

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)

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.

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

perl -le "print ~0*9999999"

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.

C++ prints 18446744073709551615

#

ULLONG_MAX is 10 characters.

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

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

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

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

Perl

9x99999999

Try it like that:

D:>perl -e "print 9x99999999" > bigNum.txt

D:>dir bigNum.txt
 Volume in drive C has no label.
 Volume Serial Number is F02E-11C0

 Directory of d:\

14.06.2014 г.  18:52        99 999 999 bigNum.txt
               1 File(s)     99 999 999 bytes
               0 Dir(s)  34 293 600 256 bytes free

Or if you're patient you can just execute perl -e "print 9x99999999" and enjoy almost 100MB of 9's printed to your console :)

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