Print largest integer you can with the fewest characters [closed]

Question

Find a way to output a large integer with few characters. Solutions will be scored based on the magnitude of the number and shortness of code.

EDIT: Let's impose a time limit of a minute on sensible hardware, where sensible is a PC you can buy off the shelves.

Answer 1

JavaScript (10)

alert(1/0)

Prints "Infinity", did I win? :)

Answer 2

bc (1 character)

9

Without a scoring method, this has a fair magnitude/length ratio indeed.

Answer 3

bash (41)

approx. 10,000,000 digits:

ulimit -t 60;while true;do echo -n 5;done

Answer 4

Python 18 characters

print hex(8**9**9)

It's about 290 million digits.

Turns out python print of decimal numbers is really slow, but hex is fast:

> time python -c "print hex(8**9**9)" | wc
   1       1 290565371
real    0m40.514s

Answer 5

Ruby - 8 chars

p $$**$$

260120641601536 digits, today on my system. ($$ is the process ID).

Answer 6

C 86 (including NL)

main(i){ 
char b[8<<14];
memset(b,'9',8<<14);
for(i=0;i<8<<15;i++)
write(1,b,8<<14);
}

Prints 34_359_973_368 digits on my i7 620M. Challenge this score!

$ gcc -O3 a.c; time ./a.out | wc -c 
34359738368

real    0m31.974s
user    0m0.500s
sys     0m41.031s

Answer 7

while(1){print 1}

Time to write is O(n) compared to length of output number.

Answer 8

bash, 35 chars, unimaginably big number

The question doesn't specify the output representation, so I'm going to go charging far past any of the numbers output by previous answers (and way way way past even Graham's number):

for((i=999;i--;))do printf 9→9;done

An even shorter answer, although with a smaller number (still larger than Graham's number) is:

(12 chars)

echo 3→3→3→3

Answer 9

PHP

1,500,050,000,000 digits in 53.383 seconds (1.5 trillion digits) in 61 characters:

$a=bcpow('1000','10000');for($i=0;$i<50000000;$i++)echo $a;

Answer 10

Mathematica, 5

10! !

10 factorial, factorial. Prints 22,228,104 digits in about 30 seconds on my machine.

Answer 11

LISP (18)

10,000,000 digits in few seconds (SBCL).

(expt 10 10000000)

Answer 12

Clojure - 28 chars (for unreasonably large numbers)

Strategy is to repeatedly apply the function f(x)=x^x. Works fine because Clojure automatically uses BigInteger arthmetic when this starts to overflow the normal integer range.

(nth(iterate #(expt % %)X)Y)

Choose X and Y depending on how unreasonably large you want the answer to be and how long you want it to run....:

For X=2:

Y=0 -> 2
Y=1 -> 4
Y=2 -> 256
Y=3 -> about 3.2*10^619 (in less than 1ms)
Y=4 -> unreasonably large

For X=9:

Y=0 -> 9
Y=1 -> 387420489
Y=2 -> about 10^320000000 
Y=3 -> ermmm..... even bigger than unreasonably large?

A couple of things to note:

• (iterate #(expt % %)X) creates an infinite lazy sequence of ridiculously large exponentials. Y just determines which term of the sequence you want to look at (as you can see above, even the very early terms get very large very fast...)
• if not already imported you need to (use 'clojure.contrib.math) for the expt function

Answer 13

Python: 83 characters, 32,089,643 digit number on my PC in a minute

import sys
sys.setrecursionlimit(1e9)
def p(n):sys.stdout.write(str(n));p(n*9)
p(9)

Note that it will either run out of time (in which case kill it) or eventually throw stack overflow errors, so you need to pipe stderr to /dev/null.

Answer 14

Windows PowerShell(7)

I guess this is cheating, but techncially the value printed is an integer:

'9'*9e6

Exactly 9000000 digits.

Can be made larger with (19):

'9'*[int]::MaxValue

but raises an OutOfMemoryException on my poor 32-bit machine. This, however, will work fine as long as it's left running:

for(){write-host -n 9}

Answer 15

PHP, 115 characters:

<? $f=fopen("/tmp/int.txt","w");for($i=$t=0;$i<2.4e7;$i++,$t++){if($t>1e4){fputs($f,$a);$t=0;}$a.=$i;}fputs($f,$a);

Outputs at least 1,024,000,00 characters to /tmp/int.txt.

File size (after running): http://codepad.viper-7.com/rgDglK

Output to Screen, 76 characters

<? for($i=$t=0;$i<2.4e7;$i++,$t++){if($t>1e4){echo $a;$t=0;}$a.=$i;}echo $a;

Has the ability to output 208, 896, 814, 305 characters, tested but unconfirmed through the output. You can confirm it by only calculating the length of the output through the second link. Each page may require a few refreshes due to errors.

Output: http://codepad.viper-7.com/rJJerv (Will crash the page eventually)
Length: http://codepad.viper-7.com/zWxX0C

Both the file size verification and the length verification take less than a minute on my old laptop, the output verification crashes the brower ~20 seconds into loading. The question did not state that the script had to work via command line, so I would not expect it to give perfect results when run that way.

Answer 16

alert(Number.MAX_VALUE); : 1.7976931348623157e+308
<script>function f(m){n=1;for(i=1;i<=m;i++){n*=i;}return n;}alert(f(f(9)));</script> : Infinity

Answer 17

time echo "7^7^7" | bc

...
29571409790619889611503701095991663965767866370599610471047901915338\
37220795832889549191447357443319063581523185421788310894001395744859\
694202869611751580402966282378932933502849310357073612870132343

real    0m58.837s
user    0m56.220s
sys 0m0.028s

on a 1.6 Mhz Pentium M.

Answer 18

cat /dev/sda

It's a 256-base Integer with 640,135,028,736 digits on my 640GB hd. Too bad some are non-printable.

Answer 19

Hmm, lets see, the largest "decimal number" I could generate on Linux, 2.4GHz Intel/Core2 w/2GB RAM, needing:

real    0m51.341s
user    0m1.820s
sys     0m5.644s

keeping user time far below 60s.

Perl, 15 characters

print 1,"0"x2e9

gives a number staring with 100000... and with about 2,000,000,000 (2 billion) zeros in total.

Regards

rbo

---

Tested with

 time perl -e 'print 1,"0"x2e9'>out

on a good hard drive.

Answer 20

Ruby - 12 chars

7.5e+306 / character of code

25.7 digits / character of code

p 9e307.to_i

Answer 21

Based on @M28 's answer

PHP 10 chars

echo 9e999

Answer 22

C

printf("-infinity");

What's your definition of "large"?

Answer 23

PHP, 18

<?for(;1;print9){}

=D

Answer 24

Ruby, 11

p 9 while 1

Or you can omit the 9 and pretend that it's outputting in the ascii representation of the number "0x0A0A0A0A..."

Answer 25

Factor, 137 characters

USING: calendar kernel io math.order sequences ;
58 seconds hence
99999 "9" <repetition> concat
[ dup write over now after? ] loop 2drop

With comments,

! calendar => seconds hence now
! kernel => dup over loop 2drop
! io => write
! math.order => after?
! sequences => <repetition> concat
USING: calendar kernel io math.order sequences ;

! Push the stop time (58 seconds after now). This leaves 2 extra seconds
! for starting and stopping the script.
58 seconds hence

! Push a long string of "9"s. The best length is near 99999.
99999 "9" <repetition> concat
[
    ! Write the very long string of "9"s.
    dup write
    ! If the stop time is after now, then loop.
    over now after?
] loop

! Empty the data stack.
2drop

This script tries to print as many "9" digits as possible, without exceeding the time limit of one minute. The number of digits changes from run to run.

Output is 10 ^ 4_765_052_349 - 1, if I must display the number in an xterm.

$ time ~/park/factor/factor scratch.factor | tee out
99999999999999999999999999999999999999999999999999999999999999999999999999999999
99999999999999999999999999999999999999999999999999999999999999999999999999999999
...
999999999999999999    0m58.56s real     0m15.63s user     0m26.21s system
$ wc -c out
 4765052349 out

Output is 10 ^ 22_843_571_562 - 1, if I never display the number.

$ time ~/park/factor/factor scratch.factor | wc -c 
 22843571562
    0m58.32s real     0m50.27s user     0m19.50s system

Additional notes:

• Each write converts the string (Unicode codepoints) to a byte array (UTF-8). This conversion might waste time inside the loop. A faster program might make a byte array before the loop, and write the byte array inside the loop; but I cannot write a byte array to the default output stream, which is a character stream. I would have to use many characters to open a binary stream.
• A faster program might call setitimer(2) and handle SIGALRM after 58 seconds. I did not find a short way to call setitimer(2) from Factor.

Answer 26

Haskell (code: 22 chars, output: 309 digits)

main=print$floor 1e309

This outputs: 179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216

Any higher exponent yields the same result, as 1e309 gets interpreted as Infinity, and this is apperantly the maximum result of floor.

Answer 27

Haskell (20 characters)

main=print.floor$1/0

Answer 28

Bash, 10 characters

seq -s9 $$

2011.8 digits per code character today on my machine.

Answer 29

Python, 21 characters

print "10"+"^10"*1337

"output a large integer"

It has 10 to the power of 10 repeated 1336 times (Tetration) number of zeros with a leading 1.

Answer 30

Windows x86 .com

8 bytes

B4 02 B2 39 CD 21 EB F8