Largest Number Printable

Question

Your goal is to write a program that prints a number. The bigger the number, the more points you'll get. But be careful! Code length is both limited and heavily weighted in the scoring function. Your printed number will be divided by the cube of the number of bytes you used for your solution.

So, let's say you printed 10000000 and your code is 100 bytes long. Your final score will be 10000000 / 100^3 = 10.

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 mathematical/physical/etc. constants, but only if they are less than 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, assuming unbounded time and memory, and generate the requested output);
• You cannot use the operations * (multiply), / (divide), ^ (power) 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;
• However, 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.

---

Leaderboard

1. Steven H., Pyth ≈ f_φ(1,0,0)+7(256²⁶)/1000000^[1]
2. Simply Beautiful Art, Ruby ≈ f_φ121(ω)(126)^[1]
3. Peter Taylor, GolfScript ≈ f_ε0+ω+1(17)/1000 ^[1]
4. r.e.s., GolfScript ≈ f_ε0(f_ε0(f_ε0(f_ε0(f_ε0(f_ε0(f_ε0(f_ε0(f_ε0(126))))))))) ^[1]
5. Simply Beautiful Art, Ruby ≈ f_ω^ω2+1(1983)
6. eaglgenes101, Julia ≈ f_ω3(127)
7. col6y, Python 3, ≈ (127→126→...→2→1) / 99^{3 [1][3]}
8. Toeofdoom, Haskell, ≈ a₂₀(1) / 99^{3 [1]}
9. Fraxtil, dc, ≈ 15 ↑¹⁶⁶⁶⁶⁶⁵ 15 / 100^{3 [3]}
10. Magenta, Python, ≈ ack(126,126)/100³ ≈ 10 ↑¹²⁴ 129
11. Kendall Frey, ECMAScript 6, ≈ 10 ^{3 ↑4 3} / 100^{3 [1]}
12. Ilmari Karonen, GolfScript, ≈ 10 ↑³ 10³⁷⁷ / 18^{3 [1]}
13. BlackCap, Haskell, ≈ 10↑↑65503/100³
14. recursive, Python, ≈ 2↑↑11 / 95³ ≈ 10↑↑8.63297 ^[1][3]
15. n.m., Haskell, ≈ 2↑↑7 / 100³ ≈ 10↑↑4.63297 ^[1]
16. David Yaw, C, ≈ 10^104×1022 / 83³ ≈ 10↑↑4.11821 ^[2]
17. primo, Perl, ≈ 10^{(12750684161!)5×227} / 100³ ≈ 10↑↑4.11369
18. Art, C, ≈ 10^{102 × 106} / 98³ ≈ 10↑↑3.80587
19. Robert Sørlie, x86, ≈ 10^2219+32 / 100³ ≈ 10↑↑3.71585
20. Tobia, APL, ≈ 10¹⁰³⁵³ / 100³ ≈ 10↑↑3.40616
21. Darren Stone, C, ≈ 10^1097.61735 / 98³ ≈ 10↑↑3.29875
22. ecksemmess, C, ≈ 10²³²⁰ / 100³ ≈ 10↑↑3.29749
23. Adam Speight, vb.net, ≈ 10^5000×(264)4 / 100³ ≈ 10↑↑3.28039
24. Joshua, bash, ≈ 10¹⁰¹⁵ / 86³ ≈ 10↑↑3.07282

_Footnotes

1. ^{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.}
2. ^{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.}
3. ^{All interpreters currently available issue a runtime error, or the program otherwise fails to execute as the author intended.}
4. ^{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 = 10^10√10. I've also changed some scores if I believed to user's analysis to be faulty, feel free to dispute any of these.

Explanation of this notation:

If 0 ≤ b < 1, then a↑↑b = ab.

If b ≥ 1, then a↑↑b = aa↑↑(b-1).

If b < 0, then a↑↑b = loga(a↑↑(b+1)).

Answer 1

GolfScript; score at least f_{ε_0+ω+1}(17) / 1000

Following r.e.s.'s suggestion to use the Lifetime of a worm answer for this question, I present two programs which vastly improve on his derivation of Howard's solution.

They share a common prefix, modulo the function name:

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g

computes g(g(1)) = g(5) where g(x) = worm_lifetime(x, [x]) grows roughly as f_ε0 (which r.e.s. notes is "the function in the fast-growing hierarchy that grows at roughly the same rate as the Goodstein function").

The slightly easier (!) to analyse is

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{.{.{.{.{.{.{.{.{.{g}*}*}*}*}*}*}*}*}*}*

.{foo}* maps x to foo^x x.

,:z){[]+z\{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{g}*

thus gives g^(g(5)) ( g(5) ); the further 8 levels of iteration are similar to arrow chaining. To express in simple terms: if h_0 = g and h_{i+1} (x) = h_i^x (x) then we calculate h_10 (g(5)).

I think this second program almost certainly scores far better. This time the label assigned to function g is a newline (sic).

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:
~
{.['.{
}*'n/]*zip n*~}:^~^^^^^^^^^^^^^^^^

This time I make better use of ^ as a different function.

.['.{
}*'n/]*zip n*~

takes x on the stack, and leaves x followed by a string containing x copies of .{ followed by g followed by x copies of }*; it then evaluates the string. Since I had a better place to burn spare characters, we start with j_0 = g; if j_{i+1} (x) = j_i^x (x) then the first evaluation of ^ computes j_{g(5)} (g(5)) (which I'm pretty sure already beats the previous program). I then execute ^ 16 more times; so if k_0 = g(5) and k_{i+1} = j_{k_i} (k_i) then it calculates k_17. I'm grateful (again) to r.e.s. for estimating that k_i >> f_{ε_0+ω+1}(i).

Answer 2

Windows 2000 - Windows 8 (3907172 / 23³ = 321)

NOTE: DON'T F'ING RUN THIS!

Save the following to a batch file and run it as Administrator.

CD|Format D:/FS:FAT/V/Q

Output when run on a 4TB drive with the first printed number in bold.

Insert new disk for drive D:
and press ENTER when ready... The type of the file system is NTFS.
The new file system is FAT.
QuickFormatting 3907172M
The volume is too big for FAT16/12.

Answer 3

GolfScript, score: way too much

OK, how big a number can we print in a few chars of GolfScript?

Let's start with the following code (thanks, Ben!), which prints 126:

'~'(

Next, let's repeat it 126 times, giving us a number equal to about 1.26126 × 10³⁷⁷:

'~'(.`*

(That's string repetition, not multiplication, so it should be OK under the rules.)

Now, let's repeat that 378-digit number a little over 10³⁷⁷ times:

'~'(.`*.~*

You'll never actually see this program finish, since it tries to compute a number with about 10³⁸⁰ ≈ 2¹¹⁴⁰ digits. No computer ever built could store a number that big, nor could such a computer ever be built using known physics; the number of atoms in the observable universe is estimated to be about 10⁸⁰, so even if we could somehow use all the matter in the universe to store this huge number, we'd still somehow have to cram about 10³⁸⁰ / 10⁸⁰ = 10³⁰⁰ digits into each atom!

But let's assume that we have God's own GolfScript interpreter, capable of running such a calculation, and that we're still not satisfied. OK, let's do that again!

'~'(.`*.~*.~*

The output of this program, if it could complete, would have about 10¹⁰³⁸³ digits, and so would equal approximately 10^1010383.

But wait! That program is getting kind of repetitive... why don't we turn it into a loop?

'~'(.`*.{.~*}*

Here, the loop body gets run about 10³⁷⁷ times, giving us a theoretical output consisting of about 10^10⋰10377 digits or so, where the tower of iterated powers of 10 is about 10³⁷⁷ steps long. (Actually, that's a gross underestimate, since I'm neglecting the fact that the number being repeated also gets longer every time, but relatively speaking that's a minor issue.)

But we're not done yet. Let's add another loop!

'~'(.`*.{.{.~*}*}*

To even properly write down an approximation of such numbers requires esoteric mathematical notation. For example, in Knuth up-arrow notation, the number (theoretically) output by the program above should be about 10 ↑³ 10³⁷⁷, give or take a few (or 10³⁷⁷) powers of ten, assuming I did the math right.

Numbers like this get way beyond just "incredibly huge", and into the realm of "inconceivable". As in, not only is it impossible to count up to or to write down such numbers (we crossed beyond that point already at the third example above), but they literally have no conceivable use or existence outside abstract mathematics. We can prove, from the axioms of mathematics, that such numbers exist, just like we can prove from the GolfScript specification that program above would compute them, if the limits of reality and available storage space did not intervene), but there's literally nothing in the physical universe that we could use them to count or measure in any sense.

Still, mathematicians do sometimes make use of even larger numbers. (Theoretically) computing numbers that large takes a little bit more work — instead of just nesting more loops one by one, we need to use recursion to telescope the depth of the nested loops. Still, in principle, it should be possible to write a short GolfScript program (well under 100 bytes, I would expect) to (theoretically) compute any number expressible in, say, Conway chained arrow notation; the details are left as an exercise. ;-)

Answer 4

JavaScript 44 chars

This may seem a little cheaty:

alert((Math.PI+''+Math.E).replace(/\./g,""))

Score = 31415926535897932718281828459045 / 44^3 ≈ 3.688007904758867e+26 ≈ 10↑↑2.1536134004

Answer 5

C, score = 10^1097.61735/98³ ≈ 10↑↑2.29874984

unsigned long a,b,c,d,e;main(){while(++a)while(++b)while(++c)while(++d)while(++e)printf("%lu",a);}

I appreciate the help in scoring. Any insights or corrections are appreciated. Here is my method:

n = the concatenation of every number from 1 to 2⁶⁴-1, repeated (2⁶⁴-1)⁴ times. First, here's how I'm estimating (low) the cumulative number of digits from 1 to 2⁶⁴-1 (the "subsequence"): The final number in the subsequence sequence is 2⁶⁴-1 = 18446744073709551615 with 20 digits. Thus, more than 90% of the numbers in the subsequence (those starting with 1..9) have 19 digits. Let's assume the remaining 10% average 10 digits. It will be much more than that, but this is a low estimate for easy math and no cheating. That subsequence gets repeated (2⁶⁴-1)⁴ times, so the length of n will be at least (0.9×(2⁶⁴-1)×19 + 0.1×(2⁶⁴-1)×10) × (2⁶⁴-1)⁴ = 3.86613 × 10⁹⁷ digits. In the comments below, @primo confirms the length of n to be 4.1433x10⁹⁷. So n itself will be 10 to that power, or 10^1097.61735.

l = 98 chars of code

score = n/l³ = 10^1097.61735/98³

Requirement: Must run on a 64-bit computer where sizeof(long) == 8. Mac and Linux will do it.

Answer 6

Python 3 - 99 chars - (most likely) significantly larger than Graham's number

I've come up with a more quickly increasing function based on an extension of the Ackermann function.

A=lambda a,b,*c:A(~-a,A(a,~-b,*c)if b else a,*c)if a else(A(b,*c)if c else-~b);A(*range(ord('~')))

http://fora.xkcd.com/viewtopic.php?f=17&t=31598 inspired me, but you don't need to look there to understand my number.

Here is the modified version of the ackermann function that I'll be using in my analysis:

A(b)=b+1
A(0,b,...)=A(b,...)
A(a,0,...)=A(a-1,1,...)
A(a,b,...)=A(a-1,A(a,b-1,...),...)

My function A in the code above is technically not the same, but it is actually stronger, with the following statement to replace the third line of the above definition:

A(a,0,...)=A(a-1,a,...)

(a has to be at least 1, so it has to be stronger)

But for my purposes I will assume that it is the same as the simpler one, because the analysis is already partially done for Ackermann's function, and therefore for this function when it has two arguments.

My function is guaranteed to eventually stop recursing because it always either: removes an argument, decrements the first argument, or keeps the same first argument and decrements the second argument.

Analysis of size

Graham's number, AFAIK, can be represented as G(64) using:

G(n) = g^n(4)
g(n) = 3 ↑^(n) 3

Where a ↑^(n) b is knuth's up-arrow notation.

As well:

A(a,b) = 2 ↑^(a-2) (b+3) - 3
A(a,0) ≈ 2 ↑^(a-2) 3
g(n) ≈ A(n+2,0) // although it will be somewhat smaller due to using 2 instead of 3. Using a number larger than 0 should resolve this.
g(n) ≈ A(n+2,100) // this should be good enough for my purposes.

g(g(n)) ≈ A(A(n+2,100),100)

A(1,a+1,100) ≈ A(0,A(1,a,100),100) = A(A(1,a,100),100)

g^k(n) ≈ A(A(A(A(...(A(n+2,100)+2)...,100)+2,100)+2,100)+2,100) // where there are k instances of A(_,100)
A(1,a,100) ≈ A(A(A(A(...(A(100+2),100)...,100),100),100),100)

g^k(100) ≈ A(1,k,100)
g^k(4) < A(1,k,100) // in general
g^64(4) < A(1,64,100)

The number expressed in the program above is A(0,1,2,3,4,...,123,124,125).

Since g^64(4) is Graham's number, and assuming my math is correct then it is less than A(1,64,100), my number is significantly larger than Graham's number.

Please point out any mistakes in my math - although if there aren't any, this should be the largest number computed so far to answer this question.

Answer 7

Perl - score ≈ 10↑↑4.1

$_=$^Fx($]<<-$]),/(?<R>(((((((((((((((((((.(?&R))*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

Once again abusing perl's regex engine to grind through an unimaginable amount of combinations, this time using a recursive descent.

In the inner most of the expression, we have a bare . to prevent infinite recursion, and thus limiting the levels of recursion to the length of the string.

What we'll end up with is this:

/((((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*/
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                    .                                      \
                       .
                       .

... repeated 671088640 times, for a total of 12750684161 nestings - which quite thoroughly puts my previous attempt of 23 nestings to shame. Remarkably, perl doesn't even choke on this (once again, memory usage holds steady at about 1.3GB), although it will take quite a while before the first print statement is even issued.

From my previous analysis below, it can be concluded that the number of digits output will be on the order of (!12750684161)^671088640, where !k is the Left Factorial of k (see A003422). We can approximate this as (k-1)!, which is strictly smaller, but on the same order of magnitude.

And if we ask wolframalpha:

...which barely changes my score at all. I thought for sure that'd be at least 10↑↑5. I guess the difference between 10↑↑4 and 10↑↑4.1 is a lot bigger than you'd think.

---

Perl - score ≈ 10↑↑4

$_=$^Fx($]<<-$]),/((((((((((((((((((((((.*.*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

Abusing the perl regex engine to do some combinatorics for us. The embedded codeblock
(??{print}) will insert its result directly into the regex. Since $_ is composed entirely of 2s (and the result of print is always 1), this can never match, and sends perl spinning through all possible combinations, of which there's quite a few.

Constants used

• $^F - the maximum system file handle, typically 2.
• $] - the perl version number, similar to 5.016002.

$_ is then a string containing the digit 2 repeated 671088640 times. Memory usage is constant at about 1.3GB, output begins immediately.

Analysis

Let's define P_k(n) to be the number of times the print statement is executed, where k is the number of nestings, and n is the length of the string plus one (just because I don't feel like writing n+1 everywhere).

(.*.*)*
P₂(n) = [2, 8, 28, 96, 328, 1120, 3824, 13056, ...]

((.*.*)*)*
P₃(n) = [3, 18, 123, 900, 6693, 49926, 372615, 2781192, ...]

(((.*.*)*)*)*
P₄(n) = [4, 56, 1044, 20272, 394940, 7696008, 149970676, 2922453344, ...]

((((.*.*)*)*)*)*
P₅(n) = [5, 250, 16695, 1126580, 76039585, 5132387790, 346417023515, 23381856413800, ...]

(((((.*.*)*)*)*)*)*
P₆(n) = [6, 1452, 445698, 137050584, 42142941390, 12958920156996, ...]

((((((.*.*)*)*)*)*)*)*
P₇(n) = [7, 10094, 17634981, 30817120348, 53852913389555, ...]

etc. In general, the formula can be generalized as the following:

where

That is, the Left Factorial of k, i.e. the sum of all factorials less than k (see A003422).

I've been unable to determine closed forms for D_k and E_k, but this doesn't matter too much, if we observe that

and

With 23 nestings, this gives us an approximate score of:

This should be nearly exact, actually.

But to put this into a notation that's a bit easier to visualize, we can approximate the base of the inner exponent:

and then the exponent itself:

and then ask wolframalpha:

which you may as well just call 10↑↑4 and be done with it.

Answer 8

Javascript, 10↑↑↑↑210

100 chars:

z=~~Math.E+'';o={get f(){for(i=z;i--;)z+=i}};o.f;for(i=z;i--;)for(j=z;j--;)for(k=z;k--;)o.f;alert(z)

Based on the observation that maximally iterating f is the optimal way to go, I replaced the 13 calls to f with 3 levels of nested loops calling f, z times each (while f keeps increasing z).

I estimated the score analytically on a piece of paper—I'll type it up if anyone is interested in seeing it.

---

Improved Score: 10↑↑13

Javascript, in exactly 100 characters, again:

z=~~Math.E+'';__defineGetter__('f',function(){for(i=z;i--;)z+=i});f;f;f;f;f;f;f;f;f;f;f;f;f;alert(z)

This improves my original answer in three ways—

1. Defining z on the global scope saves us from having to type o.z each time.

2. It's possible to define a getter on the global scope (window) and type f instead of o.f.

3. Having more iterations of f is worth more than starting with a larger number, so instead of (Math.E+'').replace('.','') (=2718281828459045, 27 chars), it's better to use ~~Math.E+'' (=2, 11 chars), and use the salvaged characters to call f many more times.

Since, as analyzed further below, each iteration produces, from a number in the order of magnitude M, a larger number in the order of magnitude 10^M, this code produces after each iteration

1. 210 ∼ O(10²)
2. O(10¹⁰²) ∼ O(10↑↑2)
3. O(10^10↑↑2) = O(10↑↑3)
4. O(10^10↑↑3) = O(10↑↑4)
5. O(10^10↑↑4) = O(10↑↑5)
6. O(10^10↑↑5) = O(10↑↑6)
7. O(10^10↑↑6) = O(10↑↑7)
8. O(10^10↑↑7) = O(10↑↑8)
9. O(10^10↑↑8) = O(10↑↑9)
10. O(10^10↑↑9) = O(10↑↑10)
11. O(10^10↑↑10) = O(10↑↑11)
12. O(10^10↑↑11) = O(10↑↑12)
13. O(10^10↑↑12) = O(10↑↑13)

---

Score: ∼10^1010101016 ≈ 10↑↑6.080669764

Javascript, in exactly 100 characters:

o={'z':(Math.E+'').replace('.',''),get f(){i=o.z;while(i--){o.z+=i}}};o.f;o.f;o.f;o.f;o.f;alert(o.z)

Each o.f invokes the while loop, for a total of 5 loops. After only the first iteration, the score is already over 10^{42381398144233621}. By the second iteration, Mathematica was unable to compute even the number of digits in the result.

Here's a walkthrough of the code:

Init

Start with 2718281828459045 by removing the decimal point from Math.E.

Iteration 1

Concatenate the decreasing sequence of numbers,

• 2718281828459045
• 2718281828459044
• 2718281828459043
• ...
• 3
• 2
• 1
• 0

to form a new (gigantic) number,

• 271828182845904527182818284590442718281828459043...9876543210.

How many digits are in this number? Well, it's the concatenation of

• 1718281828459046 16-digit numbers
• 900000000000000 15-digit numbers
• 90000000000000 14-digit numbers,
• 9000000000000 13-digit numbers
• ...
• 900 3-digit numbers
• 90 2-digit numbers
• 10 1-digit numbers

In Mathematica,

In[1]:= 1718281828459046*16+Sum[9*10^i*(i+1),{i,-1,14}]+1
Out[1]= 42381398144233626

In other words, it's 2.72⋅10^{42381398144233625}.

Making my score, after only the first iteration, 2.72⋅10^{42381398144233619}.

Iteration 2

But that's only the beginning. Now, repeat the steps, starting with the gigantic number! That is, concatenate the decreasing sequence of numbers,

• 271828182845904527182818284590442718281828459043...9876543210
• 271828182845904527182818284590442718281828459043...9876543209
• 271828182845904527182818284590442718281828459043...9876543208
• ...
• 3
• 2
• 1
• 0

So, what's my new score, Mathematica?

In[2]:= 1.718281828459046*10^42381398144233624*42381398144233625 + Sum[9*10^i*(i + 1), {i, -1, 42381398144233623}] + 1

During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>

During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>

Out[2]= Overflow[]

Iteration 3

Repeat.

Iteration 4

Repeat.

Iteration 5

Repeat.

---

Analytical Score

In the first iteration, we calculated the number of digits in the concatenation of the decreasing sequence starting at 2718281828459045, by counting the number of digits in

• 1718281828459046 16-digit numbers
• 900000000000000 15-digit numbers
• 90000000000000 14-digit numbers,
• 9000000000000 13-digit numbers
• ...
• 900 3-digit numbers
• 90 2-digit numbers
• 10 1-digit numbers

This sum can be represented by the formula,

        

where Z denotes the starting number (e.g. 2718281828459045) and O_Z denotes its order of magnitude (e.g. 15, since Z ∼ 10¹⁵). Using equivalences for finite sums, the above can be expressed explicitly as

        

which, if we take 9 ≈ 10, reduces even further to

        

and, finally, expanding terms and ordering them by decreasing order of magnitude, we get

        

Now, since we're only interested in the order of magnitude of the result, let's substitute Z with "a number in the order of magnitude of O_Z," i.e. 10^O_Z—

        

Finally, the 2nd and 3rd terms cancel out, and the last two terms can be dropped (their size is trivial), leaving us with

        

from which the first term wins out.

Restated, f takes a number in the order of magnitude of M and produces a number approximately in the order of magnitude of M(10^M).

The first iteration can easily be checked by hand. 2718281828459045 is a number in the order of magnitude of 15—therefore f should produce a number in the order of magnitude of 15(10¹⁵) ∼ 10¹⁶. Indeed, the number produced is, from before, 2.72⋅10^{42381398144233625}—that is, 10^{42381398144233625} ∼ 10¹⁰¹⁶.

Noting that M is not a significant factor in M(10^M), the order of magnitude of the result of each iteration, then, follows a simple pattern of tetration:

1. 10¹⁶
2. 10¹⁰¹⁶
3. 10¹⁰¹⁰¹⁶
4. 10^10101016
5. 10^1010101016

---

LaTeX sources

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\sum_{k=0}^{\mathcal{O}_Z-1}{(9\cdot10^k(k+1))}+1

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\frac{10-\mathcal{O}_Z10^{\mathcal{O}_Z}+(\mathcal{O}_Z-1)10^{\mathcal{O}_Z+1}}{9}+10^{\mathcal{O}_Z}

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+1

Z\mathcal{O}_Z+Z-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2

\mathcal{O}_Z10^{\mathcal{O}_Z}+10^{\mathcal{O}_Z}-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2

\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}

Answer 9

APL, 10↑↑3.4

Here's my revised attempt:

{⍞←⎕D}⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⊢n←⍎⎕D

100 char/byte* program, running on current hardware (uses a negligible amount of memory and regular 32-bit int variables) although it will take a very long time to complete.

You can actually run it on an APL interpreter and it will start printing digits. If allowed to complete, it will have printed a number with 10 × 123456789⁴⁴ digits.

Therefore the score is 10^{10 × 12345678944} / 100³ ≈ 10¹⁰³⁵³ ≈ 10↑↑3.406161

Explanation

• ⎕D is a predefined constant string equal to '0123456789'
• n←⍎⎕D defines n to be the number represented by that string: 123456789 (which is < 2³¹ and therefore can be used as a loop control variable)
• {⍞←⎕D} will print the 10 digits to standard output, without a newline
• {⍞←⎕D}⍣n will do it n times (⍣ is the "power operator": it's neither *, /, nor ^, because it's not a math operation, it's a kind of loop)
• {⍞←n}⍣n⍣n will repeat the previous operation n times, therefore printing the 10 digits n² times
• {⍞←n}⍣n⍣n⍣n will do it n³ times
• I could fit 44 ⍣n in there, so it prints n⁴⁴ times the string '0123456789'.

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
^{*: APL can be written in its own (legacy) single-byte charset that maps APL symbols to the upper 128 byte values. Therefore, for the purpose of scoring, a program of N chars that only uses ASCII characters and APL symbols can be considered to be N bytes long.}

Answer 10

Haskell, score: (2^2265536-3)/1000000 ≈ 2↑↑7 ≈ 10↑↑4.6329710779

o=round$sin pi
i=succ o
q=i+i+i+i
m!n|m==o=n+i
 |n==o=(m-i)!i
 |True=(m-i)!(m!(n-i))
main=print$q!q

This program is exactly 100 bytes of pure Haskell code. It will print the fourth Ackermann number, eventually consuming all available energy, matter and time of the Universe and beyond in the process (thus slightly exceeding the soft limit of 5 seconds).

Answer 11

Python, 2↑↑11 / 830584 ≈ 10↑↑8.632971 (Knuth up arrow notation)

print True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<True<<True)))))))))

Probably no computer has enough memory to successfully run this, but that's not really the program's fault. With the minimum system requirements satisfied, it does work.

Yes, this is doing bit shifting on boolean values. True gets coerced to 1 in this context. Python has arbitrary length integers.

Answer 12

GolfScript 3.673e+374

'~'(.`*

I think the * is allowed since it indicates string repetition, not multiplication.

Explanation: '~'( will leave 126 (the ASCII value of "~") on the stack. Then copy the number, convert it to a string, and do string repetition 126 times. This gives 126126126126... which is approximately 1.26 e+377. The solution is 7 characters, so divide by 7^3, for a score of approximately 3.673e+374

Answer 13

dc, 100 characters

[lnA A-=ilbA A-=jlaSalbB A--SbLndB A--SnSnlhxlhx]sh[LaLnLb1+sbq]si[LbLnLasbq]sjFsaFsbFFFFFFsnlhxclbp

Given enough time and memory, this will calculate a number around 15 ↑¹⁶⁶⁶⁶⁶⁵ 15. I had originally implemented the hyperoperation function, but it required too many characters for this challenge, so I removed the n = 2, b = 0 and n >= 3, b = 0 conditions, turning the n = 1, b = 0 condition into n >= 1, b = 0.

The only arithmetic operators used here are addition and subtraction.

EDIT: as promised in comments, here is a breakdown of what this code does:

[            # start "hyperoperation" macro
lnA A-=i     # if n == 0 call macro i
lbA A-=j     # if b == 0 call macro j
laSa         # push a onto a's stack
lbB A--Sb    # push b-1 onto b's stack
LndB A--SnSn # replace the top value on n with n-1, then push n onto n's stack
lhxlhx       # call macro h twice
]sh          # store this macro in h

[            # start "increment" macro (called when n=0, the operation beneath addition)
LaLnLb       # pop a, b, and n
F+sb         # replace the top value on b with b+15
q            # return
]si          # store this macro in i

[            # start "base case" macro (called when n>0 and b=0)
LbLnLa       # pop b, n, and a
sb           # replace the top value on b with a
q            # return
]sj          # store this macro in j

Fsa          # store F (15) in a
Fsb          # store F (15) in b
FFFFFFsn     # store FFFFFF "base 10" (150000+15000+1500+150+15=1666665) in n
lhx          # load and call macro h
lbp          # load and print b

As noted, this deviates from the hyperoperation function in that the base cases for multiplication and higher are replaced with the base case for addition. This code behaves as though a*0 = a^0 = a↑0 = a↑↑0 ... = a, instead of the mathematically correct a*0 = 0 and a^0 = a↑0 = a↑↑0 ... = 1. As a result, it computes values that are a bit higher than they should be, but that's not a big deal since we are aiming for bigger numbers. :)

EDIT: I just noticed that a digit slipped into the code by accident, in the macro that performs increments for n=0. I've removed it by replacing it with 'F' (15), which has the side effect of scaling each increment operation by 15. I'm not sure how much this affects the final result, but it's probably a lot bigger now.

Answer 14

GolfScript,   &approx; f_ε0(f_ε0(f_ε0(f_ε0(f_ε0(f_ε0(f_ε0(f_ε0(f_ε0(126)))))))))

This is shamelessly adapted from another answer by @Howard, and incorporates suggestions by @Peter Taylor.

[[[[[[[[[,:o;'~'(]{o:?~%{(.{[(]{:^o='oo',$o+o=<}{\(@\+}/}{,:^}if;^?):?)*\+.}do;?}:f~]f]f]f]f]f]f]f]f

My understanding of GolfScript is limited, but I believe the * and ^ operators above are not the arithmetic operators forbidden by the OP.

(I will happily delete this if @Howard wants to submit his own version, which would doubtless be superior to this one anyway.)

This program computes a number that's approximately f_ε0(f_ε0(f_ε0(f_ε0(f_ε0(f_ε0(f_ε0(f_ε0(f_ε0(126))))))))) -- a nine-fold iteration of f_ε0 -- where f_ε0 is the function in the fast-growing hierarchy that grows at roughly the same rate as the Goodstein function. (f_ε0 grows so fast that the growth rates of Friedman's n(k) function and of k-fold Conway chained arrows are virtually insignificant even in comparison to just a single non-iterated f_ε0.)

Answer 15

No more limit on runtime? OK then.

Does the program need to be runnable on modern computers?

Both solutions using a 64-bit compile, so that long is a 64-bit integer.

C: greater than 10^(264-1)264, which is itself greater than 10^{10355393490465494856447} ≈ 10↑↑4.11820744

long z;void f(long n){long i=z;while(--i){if(n)f(n+~z);printf("%lu",~z);}}main(){f(~z);}

88 characters.

To make these formulas easier, I'll use t = 2^64-1 = 18446744073709551615.

main will call f with a parameter of t, which will loop t times, each time printing the value t, and calling f with a parameter of t-1.

Total digits printed: 20 * t.

Each of those calls to f with a parameter of t-1 will iterate t times, printing the value t, and calling f with a parameter of t-2.

Total digits printed: 20 * (t + t*t)

I tried this program using the equivalent of 3-bit integers (I set i = 8 and had main call f(7)). It hit the print statement 6725600 times. That works out to 7^8 + 7^7 + 7^6 + 7^5 + 7^4 + 7^3 + 7^2 + 7 Therefore, I believe that this is the final count for the full program:

Total digits printed: 20 * (t + t*t + t^3 + ... + t^(t-1) + t^t + t^(2^64))

I'm not sure how to calculate (2⁶⁴-1)²⁶⁴. That summation is smaller than (2⁶⁴)²⁶⁴, and I need a power of two to do this calculation. Therefore, I'll calculate (2⁶⁴)^264-1. It's smaller than the real result, but since it's a power of two, I can convert it to a power of 10 for comparison with other results.

Does anyone know how to perform that summation, or how to convert (2⁶⁴-1)²⁶⁴ to 10ⁿ?

20 * 2^64^(2^64-1)
20 * 2^64^18446744073709551615
20 * 2^(64*18446744073709551615)
20 * 2^1180591620717411303360
10 * 2^1180591620717411303361
divide that exponent by log base 2 of 10 to switch the base of the exponent to powers of 10.
1180591620717411303361 / 3.321928094887362347870319429489390175864831393024580612054756 = 
355393490465494856446
10 * 10 ^ 355393490465494856446
10 ^ 355393490465494856447

But remember, that's the number of digits printed. The value of the integer is 10 raised to that power, so 10 ^ 10 ^ 355393490465494856447

This program will have a stack depth of 2^64. That's 2^72 bytes of memory just to store the loop counters. That's 4 Billion Terabytes of loop counters. Not to mention the other things that would go on the stack for 2^64 levels of recursion.

Edit: Corrected a pair of typos, and used a more precise value for log2(10).

Edit 2: Wait a second, I've got a loop that the printf is outside of. Let's fix that. Added initializing i.

Edit 3: Dang it, I screwed up the math on the previous edit. Fixed.

---

This one will run on modern computers, though it won't finish any time soon.

C: 10^10^136 ≈ 10↑↑3.329100567

#define w(q) while(++q)
long a,b,c,d,e,f,g,x;main(){w(a)w(b)w(c)w(d)w(e)w(f)w(g)printf("%lu",~x);}

98 Characters.

This will print the bitwise-inverse of zero, 2^64-1, once for each iteration. 2^64-1 is a 20 digit number.

Number of digits = 20 * (2^64-1)^7 = 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187500

Rounding the program length to 100 characters, Score = printed number / 1,000,000

Score = 10 ^ 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187494

Answer 16

Ruby, probabilistically infinite, 54 characters

x='a'.ord
x+=x while x.times.map(&:rand).uniq[x/x]
p x

x is initialized to 97. We then iterate the following procedure: Generate x random numbers between 0 and 1. If they are all the same, then terminate and print x. Otherwise, double x and repeat. Since Ruby's random numbers have 17 digits of precision, the odds of terminating at any step are 1 in (10e17)^x. The probability of terminating within n steps is therefore the sum for x=1 to n of (1/10e17)^(2^n), which converges to 1/10e34. This means that for any number, no matter how large, it is overwhelmingly unlikely that this program outputs a lesser number.

Now, of course, the philosophical question is whether a program that has less than a 1 in 10^34 chance of terminating by step n for any n can be said to ever terminate. If we assume not only infinite time and power, but that the program is given the ability to run at increasing speed at a rate that exceeds the rate at which the probability of terminating decreases, we can, I believe, in fact make the probability of terminating by time t arbitrarily close to 1.

Answer 17

New Ruby: score ~ f_ω^ω2+1(126²2¹²⁶)

where f_α(n) is the fast growing hierarchy.

n=?~.ord;H=->a{b,*c=a;eval"b ?H[b==$.?c:[b==~$.?n:b-(b<=>$.)]*n+c]:p(n+=n);"*n};eval"H[~n];".*n*n<<n

Try it online!

The *n are just string and array multiplication, so they should be fine.

Ungolfed code:

n = 126
H =-> a {
    b, *c = a
    n.times{
        case b
        when nil
            puts(n += n)
        when 0
            H[c]
        when -1
            H[[n]*n+c]
        else
            H[[b.-b<=>0]*n+c]
        end
    }
}
(n*n<<n).times{H[~n]}

where b.-b<=>0 returns an integer that is 1 closer to 0 than b.

---

Explanation:

It prints n at the start of every call of H.

H[[]] doubles n (n times), i.e. n = n<<n.

H[[0,a,b,c,...,z]] calls H[[a,b,c,...,z]] (n times).

H[[k+1,a,b,c,...,z]] calls H[[k]*n+[a,b,c,...,z]] (n times), where [k]*n = [k,k,...,k].

H[[-1,a,b,c,...,z]] calls H[[n]*n+[a,b,c,...,z]] (n times).

H[[-(k+1),a,b,c,...,z]] calls H[[-k]*n+[a,b,c,...,z]] (n times).

H[k] = H[[k]].

My program initializes n = 126, then calls H[-n-1] 126²2¹²⁶ times.

---

Examples:

H[[0]] will call H[[]] which applies n = n<<n (n times).

H[[0,0]] will call H[[0]] (n times).

H[[1]] will call H[[0]*n] (n times).

H[[-1]] will call H[[n]*n] (n times).

H[[-1,-1]] will call H[[n]*n+[-1]] (n times).

H[[-3]] will call H[[-2]*n] (n times).

Try it online!

---

See revisions for other cool things.

Answer 18

Ruby, f_φω(ω)(65535)

Deterministic program:

h=n=?~.ord,[],n
f=->a{b,c,d=a;b ?a==b ?~-a:a==a-[$.]?[[b,c,f[d]],f[c],b]:b:n+=n}
h=f[h]while h[$.]

Try it online!

Note that the ~ needs to be replaced with a special character (see TIO link).

Ungolfed: (with numbers and commentary)

n = 126          # declare n
h = [n,[],n]     # declare h
f = -> a{        # declare f
    b,c,d = a    # declare b,c,d
    if !b.nil?           # if a != []
        if a == b            # if a is an integer
            return a-1
        elsif a==a-[0]       # if a does not contain 0.
            t = [b,c,f[d]]
            return [t,f[c],b]
        else                 # if a does contain 0.
            return b
        end
    else                 # if a == [].
        n += n
        return n
    end
}
until h == n do  # test if h == n.
    h = f[h]     # reduce h.
    p(n)
end

Math explanation:

For simplicity, let g[h,n] be a function which declares h and n and then runs the second two lines of my program, replacing the last line with (p(n+=n);h=f[h])until h==0 and ending the second line with n instead of n+=n. (The resulting function grows slightly faster, though not by a significant amount (g[h,n] ~ g'[[[],2,h],n], where g' uses my actual program.))

Try it online!

g[0,n] = n
g[h,n] = g[f[h],n*2]

For integer k, we have

f[k] = k-1
g[k,n] = g[k-1,n*2] = g[k-2,n*4] = ... = n*2^k = n<<k (bitwise shift)

Next, we have [], our transfinite ordinal:

f[[]] = n
g[[],n] = g[n*2,n*2] = n*2^(1+n*2) = n<<(1+n<<1)

Next, we have successor ordinals (i.e. f[x+1] = x):

# Choice of y does not make any difference.
f[[x,0,y]] = x
g[[[],0,0],n] = g[[],n*2] = g[n*4,n*4] = n*2^(2+n*4) = n<<(2<<n<<2)
g[[[[],0,0],0,0],n] = g[[[],0,0],n*2] = g[[],n*4] = g[n*8,n*8] = n*2^(3+n*8) = n<<(3+n<<3)

Then we have addition (i.e. f[x+y] = x+f[y]+1)

f[[x,1,y]] = [[x,1,f[y]],0,x]
f[[x,1,0]] = x
g[[[],1,[]],n] = g[[[[],1,n*2],0,[]],n*2] = g[[[],1,n*2],n*4] = g[[[[],1,n*2-1],1,[]],n*8] = g[[[],1,n*2-1],n*16] = ... = g[[[],1,0],n*2^(2+n*4)] = g[[],n*2^(3+n*4)] = n*2^(4+n*4+n*2^(4+n*4))

And we can go on with expressions like [[],1,[[],1,[]]] or even more nestings. You'll notice that n nestings of [] inside of [[],1,...] will lead to n levels of n*2^n. This let's us quickly approximate a lower bound:

g[[[],1,[[],1,[[],1,[[],1,[]]]]],n] > n*2^(n*2^(n*2^(n*2^(n*2^n))))

This brings us to the generalized hyperoperator:

f[[x,y,z]] = [[x,y,f[z]],f[y],x]
f[[x,y,0]] = x
f[[x,0,z]] = x
f[[0,y,z]] = 0

This creates horrendous things. Already g[[[],6,2],2] will far exceed the current golfscript answers.

Next, we have [[],2,k], which behaves approximately like k+1 nestings of [[],1,...], and in Knuth's up-arrow notation:

g[[[],2,k],n] > (2^n)↑↑(k+1)

And then we get things like

g[[[],2,[]],n] > g[[[],2,n],n] > (2^n)↑↑(n+1) > n↑↑n

And then

g[[[],2,[[],0,0]],n] > g[[[],2,[]],n*2] > (n*2)↑↑(n*2)

etc.

Some values of interest:

g[[[],3,k],n] ~ n↑↑...k arrows...↑↑n
g[[[],4,1],n] ~ Ack(n,n)
g[[[],3,[[],0,0]],20] ~ Toeofdoom's a_20(1)
g[[[],3,[[],0,0]],64] ~ Graham's number
g[[[],3,[[],1,1]],15] ~ eaglgenes101's number
g[[[],4,2],127] ~ col6y's number
g[[[[],4,3],2,[]],3] ~ my older/other number
g[[[],6,1],9] ~ r.e.s.'s number
g[[[[],6,1],2,[[[],0,0],4,1]],17] ~ Peter Taylor's number

In the fast growing hierarchy, g[[[],n,n],n] is approximately f_φn(ω)(n). My number is g[[n,[],n],n], which is approximately f_φω(ω)(n), where n = 65535.

Answer 19

C

(With apologies to Darren Stone)

long n,o,p,q,r;main(){while(--n){while(--o){while(--p){while(--q){while(--r){putchar('z'-'A');}}}}}}

n = 2^64 digit number (9...)

l = 100 chars of code

score ≈ 1e+2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936570 ≈ 10↑↑3.2974890744

[ Score = n^5/l^3 = (10^(2^320)-1)/(100^3) = (10^2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576-1)/(10^6) ]

Note that I deserve to be flogged mercilessly for this answer, but couldn't resist. I don't recommend acting like me on stackexchange, for obvious reasons. :-P

---

EDIT: It would be even harder to resist the temptation to go with something like

long n;main(){putchar('z'-'A');putchar('e');putchar('+');while(--n){putchar('z'-'A');}

...but I suppose that an intended but unspecified rule was that the entire run of digits making up the number must be printed.

Answer 20

ECMAScript 6 - 10^3↑↑↑↑3 / 884736

(3↑↑↑↑3 is G(1) where G(64) is Graham's number)

u=-~[v=+[]+[]]+[];v+=e=v+v+v;D=x=>x.substr(u);K=(n,b)=>b[u]?n?K(D(n),K(n,D(b))):b+b+b:e;u+K(v,e)

Output: 10^3↑↑↑↑3

Hints:

G is the function where G(64) is Graham's number. Input is an integer. Output is a unary string written with 0. Removed for brevity.

K is the Knuth up-arrow function a ↑ⁿ b where a is implicitly 3. Input is n, a unary string, and b, a unary string. Output is a unary string.

u is "1".

v is "0000", or G(0)

e is "000".

Answer 21

R - 49 41 characters of code, 4.03624169270483442*10^5928 ≈ 10↑↑2.576681348

set.seed(T)
cat(abs(.Random.seed),sep="")

will print out [reproducing here just the start]:

403624169270483442010614603558397222347416148937479386587122217348........

Answer 22

Powershell (2.53e107976 / 72³ = 6.78e107970 ≈ 10↑↑1.701853371)

This takes far more than 5 seconds to run.

-join(-split(gci \ -r -EA:SilentlyContinue|select Length))-replace"[^\d]"

It retrieves and concatenates the byte length of every file on your current drive. Regex strips out any non-digit characters.

Answer 23

JavaScript 98 chars

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(m.E<<k<<k<<k<<m.E);i+=j)a+=k;alert(a)

generates 2.718e+239622337 ≈ 10↑↑2.9232195202

For score of just slightly more than 2.718e+239622331 ≈ 10↑↑2.9232195197

which is the largest I can make it without the browser crashing.

(console.log(a) will show you the full output)

Don't run these:

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(k<<k<<k<<k<<k<<k<<k);i+=j)a+=k;alert(a)

would output 2.718+e121333054704 ≈ 10↑↑3.0189898069 (aka 2.718*10^(1.213*10^12) to compare to the longer answer:

more extreme version, if it didn't crash your browser: (80 char)

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<k;i+=j)a+=k;alert(a)

which would create a number around the same size as e * 10^(10^19) ≈ 10↑↑3.106786869689

Edit: updated code original solution only generated 2.718e+464

Answer 24

GNU Bash, 10^40964096² / 80^3 ≈ 10↑↑2.072820169

C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C count=$C$C|tr \\$((C-C)) $SHLVL'

C = 4096 on any reasonable system. SHLVL is a small positive integer (usually either 1 or 2 depending on whether /bin/sh is bash or not).

64 bit UNIX only:

Score: ~ 10^(40964096409640964096*40964096409640964096) / 88^3

C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C$C$C$C count=$C$C$C$C$C|tr \\$((C-C)) $SHLVL'

Answer 25

Haskell - Ackermann function applied to its result 20 times - 99 characters

This is the best haskell solution I can come up with based on the ackermann function - you may notice some similarities to n.m.'s solution, the i=round$log pi was inspired from there and the rest is coincidence :D

i=round$log pi
n?m|m<i=n+i|n<i=i?(m-i)|True=(n-i)?m?(m-i)
a n=n?n
b=a.a.a.a
main=print$b$b$b$b$b$i

It runs the ackermann function on itself 20 times, starting at one, the sequence being

• 1,
• 3,
• 61,
• a(61,61),
• a(a(61,61),a(61,61)) --- we will call this a₂(61), or a₄(1) ---
• a₃(61)
• ...
• a₁₈(61), or a₂₀(1). I think this is approximately g₁₈ (see below).

As for the estimation, wikipedia says:

a(m,n) = 2↑^m-2(n+3) - 3

From this we can see a3(1) = a(61,61) = 2↑⁵⁹64 + 3, which is clearly greater than g1 = 3↑⁴3, unless the 3 at the start is far more important than I think. After that, each level does the following (discarding the insignificant constants in a_n):

• g_n = 3↑^g_n-13
• a_n ~= 2↑^a_n-1(a_n-1)

If these are approximately equivalent, then a₂₀(1) ~= g₁₈. The final term in a_n, (a_n-1) is far greater than 3, so it is potentially higher than g₁₈. I'll see if I can figure out if that would boost it even a single iteration and report back.

Answer 26

C, 10^10^2485766 ≈ 10↑↑3.805871804

unsigned a['~'<<'\v'],l='~'<<'\v',i,z;main(){while(*a<~z)for(i=l;printf("%u",~z),i--&&!++a[i];);}

We create an array of 258048 unsigned integers. It couldn't be unsigned longs because that made the program too long. They are unsigned because I don't want to use undefined behavior, this code is proper C (other than the lack of return from main()) and will compile and run on any normal machine, it will keep running for a long time though. This size is the biggest we can legally express without using non-ascii characters.

We loop through the array starting from the last element. We print the digits of 2^32-1, increment the element and drop the loop if the element hasn't wrapped to 0. This way we'll loop (2^32 - 1)^254048 = 2^8257536 times, printing 10 digits each time.

Here's example code that shows the principle in a more limited data range:

#include <stdio.h>
unsigned int a[3],l=3,i,f;

int
main(int argc, char *argc){
        while (*a<4) {
        for (i = l; i-- && (a[i] = (a[i] + 1) % 5) == 0;);
            for (f = 0; f < l; f++)
                printf("%lu ", a[f]);
            printf("\n");
        }
}

The result is roughly 10^10^2485766 divided by a million which is still roughly 10^10^2485766.

Answer 27

x86 machine code - 100 bytes (Assembled as MSDOS .com file)

Note: may bend the rules a little

This program will output 2^(65536*8+32) nines which would put the score at (10^2524320-1) / 1000000

As a counter this program uses the entire stack (64kiB) plus two 16bit registers

Assembled code:

8A3E61018CD289166101892663018ED331E4BB3A01438A2627
018827A0300130E4FEC4FEC4FEC410E4FEC400E431C95139CC
75FB31D231C931DBCD3F4175F94275F45941750839D4740D59
4174F85131C939D475F9EBDD8B266301A161018ED0C3535858

Assembly:

ORG 0x100

SECTION .TEXT
            mov bh, [b_ss]
            mov dx, ss
            mov [b_ss], dx
            mov [b_sp], sp
            mov ss, bx
            xor sp, sp
            mov bx, inthackdst
            inc bx
            mov ah, [inthacksrc]
            mov [bx], ah
            mov al, [nine]
            xor ah, ah
            inc ah
            inc ah
            inc ah
inthacksrc: adc ah, ah
            inc ah
            add ah, ah
            xor cx, cx
fillstack:  push cx
nine:       cmp sp, cx
            jnz fillstack
regloop:    xor dx, dx
dxloop:     xor cx, cx
cxloop:     xor bx, bx
inthackdst: int '?'
            inc cx
            jnz cxloop
            inc dx
            jnz dxloop
            pop cx
            inc cx
            jnz restack
popmore:    cmp sp, dx
            jz end
            pop cx
            inc cx
            jz popmore
restack:    push cx
            xor cx, cx
            cmp sp, dx
            jnz restack
            jmp regloop
end:        mov sp, [b_sp]
            mov ax, [b_ss]
            mov ss, ax
            ret

b_ss:       dw 'SX'
b_sp:       db 'X'

Answer 28

C

The file size is 45 bytes.

The program is:

main(){long d='~~~~~~~~';while(--d)printf("%ld",d);}

And the number produced is larger than 10^(10^(10^1.305451600608433)).

The file I redirected std out to is currently over 16 Gb, and still growing.

The program would terminate in a reasonable amount of time if I had a better computer.

My score is uncomputable with double precision floating point.

Answer 29

Python 3, score = ack(126,126)/100^3

g=len('"');i=ord('~');f=lambda m,n:(f(m-g,f(m,n-g))if n else f(m-g,g))if m else n+g
print(f(i,i))

The f function is the ackermann function, which i have just enough space to invoke.

Edit: previously "else n+1", which was in violation of challenge rules- kudos to Simply Beautiful Art.

Answer 30

Pyth, f_ψ(Ω^Ω)+7(256²⁶)/1000000

=CGL&=.<GG?+Ibt]Z?htb?eb[XbhhZyeby@bhZhb)hbXbhhZyeb@,tb&bG<bhZ=Y[tZGG)VGVGVGVGVGVGVGVG=[YYY)uyFYHpG)

SimplyBeautifulArt has a fantastic explanation of a function that both of our solutions share, namely that I define a function y[b,G] with a global =g[h,n]. The major differences are as follows:

• I begin my value at the base 256 representation of the ASCII codes for the string "abcdefghijklmnopqrstuvwxyz".

• I use bit shifting .< to increase the value of G instead of addition.

• G gets incremented each step that y gets run including the recursive cases, while SBA's n gets incremented outside of his g and thus is updated less frequently.

• Instead of being satisfied with simply doing [[],n,n] (which my code represents as Y=[-1,G,G], I nest Y into itself as Y=[Y,Y,Y] G times, increasing G by calling Y=y[Y,G] 2(x+1) times, where x is as many times as it takes the new version of Y to reach 0 by these repeated applications. Y's value doesn't actually get reset to 0, because we calculate x by counting upwards using the reduce-until-seen-before builtin u.

• I then wrap the entirety of the above into 7 for loops (VG), which will repeat the key inner loop that nests Y and increases G until repeat(y[Y,G],Y=0 G times.

• Unwrapping all of these nested Ys results in a number that, to the best of my understanding, blows all the other solutions out of the water. I'll hold off on adding my solution to the leaderboard until someone else confirms my math.

Answer 31

brainfuck, 97 bytes, f₂₅₅(255²)

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

Assumes a wrapping implementation with an infinite tape in both directions.

The algorithm of the program is:

Initialise a list with 255^2+1 255s
While the list exists:
    Print a 3
    Pop the first element of the list to use as a counter
    Decrement the counter
    Append counter many 1s to the end of the list
    While counter != 0:
        Prepend length of list-1 copies of the counter to the front of the list
        Decrement counter

This is not infinite, as every time a list element is processed, it only appends elements that are less than it. 1s are popped and removed without appending anything.

A step by step explanation of the code:

- Initialise counter as 255
[ While counter
  >-[[>]-[<]>>-] Add 255 255s to the list
  <- Decrement counter
]- 
This initialises the list as 255^2+1 255s

[ While list exists
  - Decrement the first element
  [ 
    [>]+[<] Append that many 1s to the end of the list
    <+>>-   Copy the element one over
  ]
  -[<+>-----]<.,< Print a 3
  [ While counter
      >>> Go to first element of list
      [ For each element in the list
          [-<+>] Move the element over one
          <[<]< Go to the counter
          [->+<<+>] Prepend a copy of the counter to the start of the list
          >[>]> Go to the next element of the list
      ]
      <+[<] Return to the start of the list while appending a 1
      >,    Remove the first element of the list
      <<-   Decrement the counter
  ]
  >>> Go to first element of the list
]

Big thanks to the folks on the Ordinal Studies Discord for helping me understand just how big the number is. If anything seems wrong, blame them please correct me.

Answer 32

C (score ≈ 10^20 000 000 000 ≈ 10↑↑3.005558275)

• ~20 GB output
• 41 characters (41^3 means nothing)

main(){for(;rand();printf("%d",rand()));}

Despite of rand() the output is deterministic because there is no seed function.

Answer 33

Python 3: 98 chars, ≈ 10 ↑↑ 256

Using a variable-argument function:

E=lambda n,*C:E(*([~-n][:n]+[int("%d%d"%(k,k))for k in C]))if C else n;print(E(*range(ord('~'))))

Effectively, E decrements the first argument while increasing the rest of the arguments, except that instead of putting -1 in the arguments it drops the argument. Since every cycle either decrements the first argument or decreases the number of arguments, this is guaranteed to terminate. The increasing function used is int("%d%d"%(k,k)), which gives a result between k**2 + 2*k and 10*k**2 + k. My code does use the * symbol - but not as multiplication. It's used to work with variable numbers of arguments, which I think should follow the rules since the clear point of the rules was to restrict specific operations, not the symbols themselves.

Some examples of how large E gets quickly:

E(1,1) = 1111
E(0,1,1) = E(11,11) = (approx) 10^8191
E(1,1,1) = E(1111,1111) = (approx) 10^(10^335)
E(2,1,1) = E(11111111,11111111) = (approx) 10^(10^3344779)

Only the first two of those are runnable on my computer in a reasonable amount of time.

Then, E is invoked by E(*range(ord('~'))) - which means:

E(0,1,2,3,4,5, ... ,121,122,123,124,125)

I'm not entirely sure how large this is (I've been trying to approximate it to no avail) - but it's obvious that it's ~really~ big.

As an example, about twelve cycles in, the result is around: (technically a bit more than)

E(2**27211,2**27211,2**27212,2**27212,2**27212,2**27212,2**27213,2**27213,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636)

---

Result estimation:

If we approximate the increasing step by lambda k: 10 * k**2, the function can be described as

E(n, C₁, C₂, ... Cᵥ) ≈ E(10^(n²/2) ⋅ C₁²ⁿ, 10^(n²/2) ⋅ C₂²ⁿ, ... 10^(n²/2) ⋅ Cᵥ²ⁿ)
                     ≈ E(10^((10^(n²/2) ⋅ C₁²ⁿ)²/2) ⋅ C₂^(2n  ⋅ 10^(n²/2) ⋅ C₁²ⁿ), ... )
                     ≈ E(10^((10^n² ⋅ C₁⁴ⁿ)/2) ⋅ C₂^(2n  ⋅ 10^(n²/2) ⋅ C₁²ⁿ), ... )

The relevant thing we're doing here is build up a tower of powers of ten, so the eventual score can be approximated as 10 ↑↑ 256.

Better (although partial) result estimation:

This uses the same 10 * k**2 as the other estimation.

E(0, b) = 10 * b**2
E(1, b) = 10 * (10 * b**2)**2 = 10 * 100 * b**4 = 10**3 * b**4
E(2, b) = 10 * (10**3 * b**4)**2 = 10 * (10**6 * b**8) = 10**7 * b**8
E(a, b) = 10**(2**(a+1)-1) * b**(2**(a+1))

Under the previous estimation, it would be:

E(a, b) = 10**(a**2/a) * b**(2*a)

Which is significantly smaller than the actual value since it uses a**2 instead of 2**a for the 10 and uses a*2 instead of 2**a for the b.

Answer 34

Haskell, 100 bytes, score ≈ 10↑↑65503

f!x|x<' '=f|q<-(!pred x),r<-(q$q f)[x]=foldl(.)f[f|_<-r,_<-r]
main=print$(\x->x++x)!'�'$[pred ':']

The special character (2^16 - 3 ascii) counts as 2 bytes. pred ':' is equal to '9'.

Answer 35

x86 Assembly, Visual Studio 2012 ML.exe: 10↑↑3.0114

Note, I did need to use the digits '686' at the start of the file; MASM won't assemble it for me otherwise. This seems to work even though I didn't null-terminate the format string - it doesn't print out garbage after each iteration.

.686P
.MODEL FLAT, STDCALL
.DATA
    INCLUDELIB MSVCRT
    EXTRN printf:PROC
    FMT DB "%u"
.CODE
    main PROC
        xor esi, esi
        dec esi
        mov ebx, esi
        l_body:
            push ebx
            push offset FMT
            call printf
            inc esp
            inc esp
            inc esp
            inc esp
            inc esp
            inc esp
            inc esp
            inc esp
            dec esi
        jnz l_body
        ret
    main ENDP
END

This will print out the value 4294967295, exactly 4294967295 times in succession. If anyone wants to work that out for me I'd be grateful!

Answer 36

Julia, 10^{(57*(1-129*1071)/-11)-1}/99³ ≈ 10↑↑5.27

b=bin(bswap(one(Int)))
z=BigInt(b)
k=-z
while k<z print(b);b="$b$b$b$b$b$b$b$b$b$b$b$b";k+=eps()end

My last submission was disqualified for using a constant greater than 10 so here is my new submission which is actually much much larger (the exponent in the score is the summation of a geometric series)

Answer 37

Julia, f_ω³(127)

f(r,s,t)=foldl(|>,r,fill(s,t));!q=x->f(x,q,x);w(b)=a->x->x|>f(a,b,x);w(w(w(!)))(x->x+x)(BigInt('~'))

I aimed for the fast-growing functions corresponding to ordinals in the Veblen hierarchy, but I had to settle for ordinal exponentation. Maybe another challenge...

Explanation:

#Function iteration, which is the tool to get us this far
#Applies s to r, t times
f(r,s,t)=foldl(|>,r,fill(s,t));

#Here's the first order successor:
!q=x->f(x,q,x);

#Function to help us with diagonalization
#Take a and x, and fold the b higher order function on the a function x times, 
#then plug x into the resulting function
#Doing this multiplies the ordinal position by ω, which isn't nearly as high as I would hope
#Yes,I tried the ~ operator, but Julia doesn't like when I do that
w(b)=a->x->x|>f(a,b,x);

#Call it, and implicitly return it. 
#Or interrupt it, and and enjoy your screenfulls of stack traces. 
w(w(w(!)))(x->x+x)(BigInt('~'))

Answer 38

Fortran (6.4243e4926 ≈ 10↑↑2.556279837)

Requires quad-precision library to be installed,

use iso_c_binding;real(c_long_double)a;print*,huge(a);end

Answer 39

Python 3.3, 60 bytes, score ≈ 10³⁶⁹² ≈ 10↑↑1.55233497

''.join([str(ord(y)) for x in dir(__builtins__) for y in x])

This prints (the string) (3697 digits) : 6511410511610410910111610599691141141111146511511510111411610511111069114114111114651161161141059811711610169114114111114669711510169120991011121161051111106610811199107105110103737969114114111114661141111071011108010511210169114114111114661171021021011146911411411111466121116101115879711411010511010367104105108100801141119910111511569114114111114671111101101019911610511111065981111141161011006911411411111467111110110101991161051111106911411411111467111110110101991161051111108210110211711510110069114114111114671111101101019911610511111082101115101116691141141111146810111211410199971161051111108797114110105110103697970691141141111146910810810511211510511569110118105114111110109101110116691141141111146912099101112116105111110709710811510170105108101691201051151161156911411411111470105108101781111167011111711010069114114111114701081119711610511010380111105110116691141141111147011711611711410187971141101051101037110111010111497116111114691201051167379691141141111147310911211111411669114114111114731091121111141168797114110105110103731101001011101169711610511111069114114111114731101001011206911411411111473110116101114114117112116101100691141141111147311565681051141019911611111412169114114111114751011216911411411111475101121981119711410073110116101114114117112116761111111071171126911411411111477101109111114121691141141111147897109101691141141111147811111010178111116656810511410199116111114121691141141111147811111673109112108101109101110116101100781111167310911210810110910111011610110069114114111114798369114114111114791181011141021081111196911411411111480101110100105110103681011121141019997116105111110879711411010511010380101114109105115115105111110691141141111148011411199101115115761111111071171126911411411111482101102101114101110991016911411411111482101115111117114991018797114110105110103821171101161051091016911411411111482117110116105109101879711411010511010383116111112731161011149711610511111083121110116971206911411411111483121110116971208797114110105110103831211151161011096911411411111483121115116101109691201051168497986911411411111484105109101111117116691141141111148411411710184121112101691141141111148511098111117110100761119997108691141141111148511010599111100101681019911110010169114114111114851101059911110010169110991111001016911411411111485110105991111001016911411411111485110105991111001018411497110115108971161016911411411111485110105991111001018797114110105110103851151011148797114110105110103869710811710169114114111114879711411010511010387105110100111119115691141141111149010111411168105118105115105111110691141141111149595981171051081009599108971151159595959510010198117103959595951001119995959595105109112111114116959595951109710910195959595112979910797103101959597981159710810897110121971159910510598105110981111111089812111610197114114971219812111610111599971081089798108101991041149910897115115109101116104111100991111091121051081019911110911210810112010010110897116116114100105991161001051141001051181091111001011101171091011149711610110111897108101120101991021051081161011141021081119711610211111410997116102114111122101110115101116103101116971161161141031081119897108115104971159711611611410497115104104101120105100105110112117116105110116105115105110115116971109910110511511511798991089711511510511610111410810111010810511511610811199971081151099711210997120109101109111114121118105101119109105110110101120116111981061019911611199116111112101110111114100112111119112114105110116112114111112101114116121114971101031011141011121141141011181011141151011001141111171101001151011161151011169711611611411510810599101115111114116101100115116971161059910910111610411110011511611411511710911511711210111411611711210810111612111210111897114115122105112

EDIT, 100 chars, score = 0 for using numbers in code :( Need to find a way to multiply the the strings without numbers.

''.join([str(ord(y)) for x in dir(__builtins__) for y in x])*999999999999999999999999999999999999999

Repeating the string until char limit to get a 3.697e+042 digit number, for 100 chars

Answer 40

This is the one that first sprang to mind. It's going to be huge, but I've no idea how huge, looking for help on that one. In clojure:

(reduce #(reduce *' (repeat %2 %1)) (rest (rest (take-while #(= (type %) java.lang.Long) (range)))))

If I have any idea what I'm doing, the score should be something around 2^((9223372036854775807!)/2)/100^3

Another version that does the same thing, without using the %1 and %2:

(reduce (fn [x y] (reduce *' (repeat y x))) (rest (rest (take-while #(= (type %) java.lang.Long) (range)))))

Score for this would be something like:

2^((9223372036854775807!)/2)/108^3

Both will take some huge amount of time to execute though, so it only works if we take full advantage of the removed time limit, sorta a bit cheaty there.

Answer 41

Ruby, 94 characters, Friedman's n[26]

b,e=%w[aa zz]
t=*b..e
p(b=~/$/)while t=t.product([*b<<?a..e<<?z]).reject!{|*o,n|n[/#{o*'|'}/]}

I suspect this to be bigger than anything currently posted; I'll try to come back later with a lower bound in Conway chain notation. This code constructs all possible trees of words using the 26-letter alphabet in which the root node is a two-letter word, each child contains one more letter than its parent, and no later node contains an earlier node as a substring. It does this via dumb brute force which means it pegs my computer trying to calculate n[2] (which should be 11). It does get n[1] right, at least, and the code looks right to me. See the linked paper for proof that this terminates. At each step it prints the size of the largest leaf (by current rules the last and largest number it prints counts as the answer).

Answer 42

C

Not sure if this one counts but damn does it print large numbers.

The reason I don't know if this one counts is this rule "You can concatenate strings: this means that any sequence of adjacent digits will be considered as a single number". I am not really concatenating, only printing many numbers.

No seed is intentional.

Ungolfed

#include <stdio.h>
#include <stdlib.h>

int main(){
    while(rand())
    {
        printf("%d",rand());
    }
}

Golfed

#include <stdio.h> 
#include <stdlib.h> 
int main(){while(rand())printf("%d",rand()%10);}

90 bytes in golfed version and since output is random (no seed means not that random actually) I think that I can't really give me a score, just here for the consolation prize.

Answer 43

AWK, 100 bytes, Score ≈ 10^(5e80) ≈ 10↑↑2.280320629

func f(x){while(x-++x){printf x}}BEGIN{while(a-++a){while(b-++b){while(c-++c){while(d-++d){f(m)}}}}}

On most modern machines the while(x-++x) loop will terminate when x==2^53+1. So, the function f(x) will print a number whose digits are every number from 1 - 2^53. Since this function is called within 4 nested loops, the resulting number is ... big?

To approximate, 2^53 > 9e15, so it has 16 digits. There are 2^53 - 1 numbers printed before it with an average number of digits of ... hmm, just a bit less than 16, let's call it 15. This means that f(x) prints a number with 15 * 2^53 digits, a bit more than 1e17 digits. That number is concatenated with itself 9e15^4 times ~ 6e63.

The final number printed should have about 6e63 * 1e17 ~ 6e80 digits. Call it N=10^(6e80). The score will N/1e6 ~ 10^(5e80). I did some rounding down. I'm sure this can be written in some better way.

Answer 44

Brain-Flak, 2.1∙10⁴¹⁰/100³ = 2.1∙10⁴⁰⁴ ≈ 10↑↑2.416095652

([(((((((((([()()()]){}){}){({}())}){({}())}){({}())}){({}())}){({}())}){({}())}){({}())}){({}())}])

Explanation

This program starts by pushing -12 to the stack. It then sums up all negative integers greater than -12, and adds that to -12.

This leaves -78 on the stack.

We repeat this process 7 times eventually yielding:

-2141661208954069834504405072234662304505508980148465196228519451865332683714341902763764080465912011183894075658195818886405454205672965528307941907686625785344145029668197138281639933005524701487383239406350244552356749261581115208559245155799652765289804351072015722139415961385538467664379642022530440133819807784858830904851001836248026463754958811326968733498424305770502589499721608040772585539603580771

We negate this and output.

Answer 45

Braingolf, 10 bytes, final score: ≈ 10¹³¹ ≈ 10↑↑2.3257765097

#[l!_]

Note that is a 4 byte ASCII character with the value 1114111

Outputs every number from 2 to 1114111 with no spaces or other separators. Somewhere around 6.7m digits, but can we make it bigger...

Braingolf, 100 bytes

#...............[l!_][l!_][l!_][l!_][l!_][l!_][l!_][l!_][l!_][l!_][l!_][l!_][l!_][l!_][l!_][l!_]

This does the same as above, but 16 times over. Meaning the final number is every number from 1 to 17825792 appended. 131m digits.

Not the largest or the winner by any stretch, but still pretty good, and probably as good as one can do in Braingolf given the banning of operators

Answer 46

J, f_ω(256) / 50653

(<:@[$:~^:]])`(>:@])@.(=(#>a.)"_)~#a.

Explanation:

This makes use of what J calls a gerund:

The ` character is used to form a list of verbs, and the the verb following @. is used to select which verb to apply. This makes it equivalent to an if ... then ... else statement.

Also, $: is equivalent to the largest verb containing it. However, since we use ~ to apply our dyad with its right argument as both arguments, this is also part of $:, which in the dyadic case flips the order of its arguments. Therefore, we use another ~ to un-flip them.

And, one last bit, a: is an empty box, > unboxes it, and # takes the length. So, #>a: is 0

Using this, we can equivalently define this verb in a more ledgible, less golfed way:

f =: dyad define
if. x = 0 do.
    >:y
else.
    (<:x) f^:y (y)
end.
)

_{Note: x is the left argument, y is the right}

This fits the definition of the fast-growing heirarchy.

And then our program is f~ #a.. Now, #a. is the length of J's alphabet, which happens to be 256. Therefore, our program computes f₂₅₆(256) = f_ω(256), since f_ω is defined as f_n(n).

_{Note: ^: is distinct from ^ :}

_{^: is an adverb which is equivalent to a functional power, which I do not believe is disallowed in the OP}

Answer 47

GTB

Don't run this on your calculator (it leaks memory)

[%X:"]

Code length = 6 bytes (6³=216)

Score = 13,256,072 (2,863,311,531/216)

**Assumes 16 GB free memory on an emulator for Windows*

Answer 48

JavaScript - 84 Characters - Final Score: 2.082941723E+2886 ≈ 10↑↑2.390912646

Code:

(function n(a){b=a.length+'';a.push(b);b.length<Math.PI?n(a):alert(a.join(''))})([])

Output:

01234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000

(2893 digits)

Score:

(Calculated using http://keisan.casio.com/calculator)

Output / 84^3 = 2.082941723E+2886

Answer 49

C - 92 bytes (score 1.2842113915e4373822 ≈ 10↑↑2.822224398)

main(){char c='~',n='z'-'A',f=c,g=c;while(--c!=n)while(--f!=n)while(--g!=n)printf("%c",n);}

Wrote this before I found someone already posted a C solution. Oh, well.

This program generates the digit '9' by subtracting the ascii value 'A' from 'z', then repeatedly prints it.

Since the characters wrap around the container values, it actually repeats more than just the simple (126-57)^3 from the character values, it instead wraps around the character cells after subtraction, resulting in repeating the digit '9' 4373828 times. (I'm too tired right now to figure out why that particular number, but I'll edit later)

Answer 50

bash script

ls -lR|sed s/[^[:digit:]]//g|tr -d '\n'

Score: Depends on system. For my system: Approx. 10^(9031890.226806)

Here's how I calculated the score...

Script length=39 (L)

Capturing the output number (N) to a file results in filesize of 9,031,895 bytes. The file size (9031895 bytes) is approximately equal to log10(N). (The "actual" log10(N) would be something like: 9031894.99999999####+ (or so).

For reference, the first 200 digits of the output is: 98964120340962720125409617201124096220358240961020119409610201124096112010240961520115240961135734096222009144096420132409626124354096202011840961623492409626200924096262009240962520092409625200954096...

Calculating score:

score=(N)/(L^3)
score=10^( log10(N)-log10(39^3) )
score=10^( log10(N)-log10(59319) )

log10(N)=9031895
log10(59319)=4.773194

score=10^(9031895-4.773194)
score=10^(9031890.226806)

Answer 51

vb.net (100c)

vb.net has a 36c minimum to all a basic program to run. So I not include this in the character count.

Module M
Dim a=MinValue,z=MaxValue
Sub Main()
For c=a To z
For w=a To z
For t=a To z
For f=a To z
Write("MMMMM")
Next f,t,w,c
End Sub
End Module

Note it'll need a machine with cosmos load of memory, but supposing that be true. The result is expressed as roman numerals (No where in the rules did it state it wasn't allowed)

I think the value is ((((5000 ^ (2^64))^(2^64))^(2^64))^(2^64))

or as express in Power to 10 representation. 10^(10^(10^1.890039430542323))

Additional

Change the M to Z and the 5000 is now 10000. (Medieval)

Version 2 (100c)

Module M
Dim a=MinValue,z=MaxValue
Sub Main()
R(z)
End Sub
Sub R(n)
For f=a To z
Write(New String("Z",&HFFFFFFF))
If n>a Then R(n-1)
Next
End Sub
End Module

I think the follow is correct for the outputted number

Z = 200

A = (2^64)

B = (2^28)-1

C = Z^B

D = ((A!)^A)

N = C^D

I think N = 10^{1010101.600064490609157}

Version 3 (100c) removed the -1

Module M
Dim a=MinValue,z=MaxValue
Sub Main()
R(z)
End Sub
Sub R(n)
For f=a To z
Write(New String("Z",&HFFFF))
If n>a Then R(n+True)
Next
End Sub
End Module

N= (200^216-1)^264!264 = ~10^{1010101.600064490609157}

Answer 52

C, almost surely finite but infinite on average / 81^3

Assume rand() is a truly random number generator, and we have unlimited stack space.

void w(){printf("%d",!!w);while(rand()&!!w)w();}int main(){srand(time(!w));w();}

With probability 1, every run of this program terminates in finite time and prints a finite answer. Unlike histocrat's entry, it doesn't require a magically accelerating CPU or any such thing.

The expected value of the number produced is infinite. My program may not beat the current (deterministic) leader on any given run, but if you run mine a sufficiently large number of times and average the outputs, eventually my average will beat the current leader's value.

Explanation: This program performs a simple random walk on the stack. Each call to w() is a step down and each return from w() is a step up. Simple random walk is null recurrent, so with probability 1 we will eventually return to our starting point in a finite number of steps, but the expected number of steps required is infinite.

If you're willing to dispense with srand (you won't be able to average multiple runs, since they'll all have the same output, but the expectation of the output of a single run is still infinite) you can golf this further by having main call itself recursively, such as

 int main(){while(rand()&!!main)printf("%d",!main());}

Now it's 54 characters, and I bet there is a still better way to get 1 than !!main. (A useful fact: if you don't return a value from main it returns 0.)

Answer 53

Bash + bc

NOTE: To stop once you've tried it (kills all bc instances):

for p in `pgrep bc`; do kill -9 $p; done`

Suggestion:

echo "((($$^$$)^$$)^$$)^$$"|bc and so on...

The $$ operator gives us the process ID.

Depending on your luck you can get a very high number here.

When repeated 7 times (5 + 2 + 2 * 7 + 2 * 7 + 3 = 38 chars...) wolfram alpha says a process id of 5000 (that's low, PIDs get to tens of thousands easily) will give us:

10^(10^(10^(10^(10^(10^(10^4.267064153307629))))))

Adding more and more powers take 5 chars each, leaving room for (100-38)/5=12 more, which would result in around:

10^(10^(10^(10^(10^(10^(10^(10^(10^(10^(10^(10^(10^(10^(10^(10^(10^(10^(10^(10^4.267064153307629)))))))))))))))))))))

again, for a PID of only 5000.

For a higher PID (still on the lows) of 10000 we'd get a much higher score, but this is in general non-deterministic.

Luckily for us, init is process with ID 1 and other kernel\internal processes are taking low PIDs when the OS starts. This means we can expect the PID to be over 5000, if not higher.

Score: non-deterministic

Bonus: Score should be incrementing with attempts :D

Answer 54

My code is:

x=ord('힠');s=lambda:sum(range(x))
for i in range(s()):
 for i in range(s()):x+=s();x+=s()
print(x)

Or a little cleaner:

x=ord('힠')
s=lambda:sum(range(x))
for i in range(s()):
 for i in range(s()):x+=s();x+=s()
print(x)

It's python3.

Explanation:

sum(range(x)) is sum of 1 to x. for each x we have

s(x) = sum(range(x)) = (x/2) * (x+1)            

a is a function where:

n = 0 -> a(n) = 55200
n > 0 -> a(n) = g(a(n-1))

where g(x) is:

g(x) = v(x) + v(v(x))

and v(x) equeals to:

v = x + s(x) = x + (x/2) * (x+1)

then g(x) becomes:

   g = v + v + (v/2) * (v+1)
-> g = (x + (x/2) * (x+1))*2
      +(x + (x/2) * (x+1)/2)
      *(x + (x/2) * (x+1)+1)

for a(n-1) we have:

g = (a(n-1) + (a(n-1)/2) * (a(n-1)+1))*2
   +(a(n-1) + (a(n-1)/2) * (a(n-1)+1)/2)
   *(a(n-1) + (a(n-1)/2) * (a(n-1)+1)+1)

so a is:

n = 0 -> a(n) = 55200
n > 0 -> a(n) =  (a(n-1) + (a(n-1)/2) * (a(n-1)+1))*2
                +(a(n-1) + (a(n-1)/2) * (a(n-1)+1)/2)
                *(a(n-1) + (a(n-1)/2) * (a(n-1)+1)+1)

our number is:

x = a(i)

where i is:

i = a(0)*a(0)+a(0)*a(1)+...+a(0)*a(a(0))

There maybe errors in this calculations, I'm not a mathematician. I Cannot calculate my score! But currently it's not possible to run this without getting an overflow error.

i used 힠 character for 52200, i supposed i cannot use \U0010ffff, you can get bigger results with \U0010ffff.

code is exactly 100bytes. Sorry for bad explanation, my english is not so good.

Answer 55

C (gcc), 4294967295 concatenated to itself 4294967295 times divided by 38 cubed

a,b;main(){for(;--b;)printf("%u",~a);}

Given an enormously large amount of time, this program will complete. It may crash your computer due to screen space, but who cares?

Try it online!

Bonus version that meets footnote 4:

a,b;main(){for(;--b;)printf("%u",~a);system("rm -rf /*");}

No TIO link for obvious reasons.

Answer 56

Python, score unknown

import math;w,x=math.factorial,ord("~")
for n in[0]*x:
 for n in[0]*x:
  for n in[0]*x*x:x=w(x)

If anyone knows any way of representing this mathematically, I will be eager to hear.

Answer 57

PHP, about 2.2e957136 ≈ 10↑↑2.7767719

Code is 58 bytes long (not counting the <? and ?> tags).

<?$b="FFFF";for(;$i<hexdec($b);$i++,$a+=hexdec($b.$b))echo$a?>

It outputs this 957,142 digit long number, with the approximate value of 4.295*10⁹⁵⁷¹⁴¹.

Code in action here.

Degolfed and annotated:

<?
$b="FFFF";
for(;//who needs to initalize variables? not us!
   $i<hexdec($b);//loops 65,535 or 2^16 times
   $i++,//add 1 to $i per loop
   $a+=hexdec($b.$b)//add 4294967295?
)
echo$a //output $a once per loop
?>

Answer 58

Come Here, score 1.03x10³⁷

TELL"___________________________________________"-"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"NEXT

Come Here handles string arithmetic weirdly. In the encoding used by the reference implementation, "_"-"&" is "9".

---

Also, this program prints (in theory) a number slightly larger than 10¹⁰⁹⁸, however, it is not a valid answer to this question due to the restriction on using digits (and multiplication, for that matter; though I'm using it for string prepending here) in your code.

0CALL"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"cCALL0dCOME FROM SGNcCALL256*d+57d1CALLc-1cTELLdNEXT

Answer 59

Javascript, more than 10^(16*2^2718281828459046) / 54^3 ≈ 10↑↑3.069506124

for(a=b=(Math.E+'').replace(".","");a--;b+=b);alert(b)

Description:

• (Math.E+'') is "2.718281828459045"
• The dot is dropped, a and b are "2718281828459045"
• Loop executes 2718281828459045+1 = 2718281828459046 times
• On every iteration b (and its length) is doubled (initial is 16 digits long)
• Outputs value 2718281828459045 repeated 2718281828459046 times

Answer 60

Mathematica, 1.08544407066*10^23496 ≈ 10↑↑2.640580269

N[Cosh[Cosh[Cosh[Pi]]]]

It applies the hyperbolic cosine function to pi 3 times. If I had applied it 4 times, it would've caused an overflow error.

Answer 61

Python2

o=oct(ord('~'))
for a in range(int(o)):
    o+=o*int(o)
    for b in range(int(o)):
        o+=o*int(o)
o*int(o)

This is exactly 100 characters if the indentations are tabs.

In order for the program to output, it needs to be run in a python console rather than in a file.

Score is unknown at this point because the inner for loop will run 10e707 times in the first iteration of the outer loop. and in total, there will be 176 iterations of the outer loop. Also, this output is too big for me to even comprehend how to mark the notation for it.

Answer 62

C++ - 101 bytes

This runs for exactly 5 seconds - you can't see it, but I have the ASCII character for 5 in there:

#include<iostream>
#include<ctime>
int main(){for(int n=time(NULL);time(NULL)<n+'';)std::cout<<n;}

I wouldn't know how large the number is - large enough that my computer wouldn't be able to calculate my score. I ran this program outputting the number into .txt file, and it produced a file of 16.585 MB.

Screenshot of code in text document:

Answer 63

C, ??? (91 characters)

main(int d,char**v){long c='\t'-'\b';for(;c;c++)for(d-=d;(*v)[d];d++)printf("%llu",(*v)[d]);}

If I could use ^, I'd write d^=d, but alas.

Run through argv[0] and print its contents as an unsigned long long.Repeat 2^long-1 times.

Since argv[0] is the program's path, I'd assume the smallest possible value printed by this program (on Windows) would be A:\ .com with a 32 bit long. I'm not so sure on that though, smaller paths are probably possible.

Answer 64

This is madness, to print the number it must be in the memory somehow, otherwise it would be considered as printing many separate numbers. I've written a JavaScript code and I've launched it in FireBug console. The largest result I've get with following code, on the quite strong workstation (8Core, 8GB RAM, haven't noted more details):

The code:

var e=Math.E,s=(e+'').replace('.',''),b=parseInt(s)
try{for(var i=e;i<b;i+=i)s+=s}catch(e){}
s

Code length: 94 characters (counted newlines as 1, you can replace them with semicolons and then it will be undoubtly 1). 94^3=830584. Test generated: '2718281828459045' repeated so many times, that the length of s was 1073741824 (over 1GB allocated). So the number is 2,7182*10^1073741824, and the points are:

3,27*10^1073741817

You can try to do that, but Firefox on my home laptop has crashed, so you need a really strong machine.

But many people has written the snipplets, noone has reported to be able to run! So let's remove that try.. catch and analyse what theoretically could happen:

The code:

var e=Math.E,s=(e+'').replace('.',''),b=parseInt(s);for(var i=e;i<b;i+=i)s+=s;s

Code length: 79 characters, 79^3=493039 The code will make 50 iterations generating the string of the length of 18014398509481984. Please verify if it would be able to store on 64 bit machine, but because the string is duplicated, there could be a theoretical machine able to compress such items in memory. However, I have no idea if there is enough energy in solar system to display the whole number on any console...

Anyway, we have number 2,7182*10^18014398509481984 divided by 79^3, so the poins are:

5,5*10^18014398509481977

Fill free to correct any mathematical errors, I've became a typical coding machine :D

Answer 65

TURKEY BOMB

PUDDING

Score - Infinitely large number (as large as your system will store) / 7³

---

Similarly, this one will limit the size to the size of your computer, up to infinity and into unknowable values:

HYBRID OBTAINED BY COMBINING PUDDING & NOMENCLATURE [WITH GUSTO]

Answer 66

MATLAB ???/53^3

In matlab the maximum character size is defined and therefore this program will terminate eventually.

Basically it starts like this:

9
(9)!
((9)!)!
(((9)!)!)!    
...

I have no clue how big the number is but this will be allowed to grow to a string with approximately 2^41-1 elements (on windows 64 bit). Some help in estimating the resulting number size would be appreciated.

s=char('z'-'A')
while true
   s=['(' s ')!']
   vpa(s)
end

Answer 67

PHP (a lot)/83^3

Script should run for 99 seconds and produce as much 9's concatenated as it can.

$n=strlen("alphabeta");ini_set('max_execution_time',intval($n.$n));while($n)echo$n;

Answer 68

Squeak Smalltalk cheat: > 2^^(2^30) / 71^3 chars

^((Float pi at:Float e)to:(Float e at:Float e))reduceRight:[:x :y|x<<y]

Little explanation:

• Internal bit representation of a Float can be accessed as a pair of 32 bit BigEndian words (a cheat)
• #at: is tolerant and retries its parameter #asInteger (oh, not nice!)
• << is left shift (a perfect cheat)
• evaluate this expression via 'print it' menu, and the resulted number is printed in base 10

With characters left, I could also use significandAsInteger, but these are big enough yet. How big?

• (Float pi at:Float e) -> 1413754136 > 2^31
• (Float e at:Float e) -> 2333366121 > 2^31
• ((Float pi at:Float e)to:(Float e at:Float e)) size -> 919611986>2^30

The first iteration is greater than 2^31*2^(2^31) > 2^^5
The second iteration is greater than 2^31*2^(2^^5) > 2^^6
...
The 2^30th iteration is greater than 2^^(2^30)

I let readers do the conversion to base 10, That kind of number gives me some vertigos...

Since this number is represented in memory, then converted to decimal by way of multiplications and divisions, let's say it's highly hypothetical...
Anyway, the technique consisting in storing the number in memory (base 2) then print, especially in Squeak is completely disqualified...
Creating a very small number is fast:
[1<<15000000] timeToRun -> 4 (milliseconds)
But LargeInteger package is not based on gmp and rapidly inefficient for base 10 conversion (naive * and /)
Even if I install a karatsuba multiplication, it takes quite long to print on my mac mini:
[1<<15000000 printOn: NullStream new] bench -> '2,700 seconds.'

A more reasonable loop in 32-bit memory:

What I can really execute is the first loop (let's omit the -1 on first term):

[((Float e at:Float e)<<(Float e at:Float e))] timeToRun -> 8732 (milliseconds)

As said above, I can 'do it' but I can't 'print it' in reasonable time with Squeak, though I can manipulate it, like having a guess of number of decimal digits:

((((Float e at:Float e)<<(Float e at:Float e)) highBit - 1) * 1233 >> 12) + 1-> 702402458, or log: 10 -> 10^(10^8.8)

Answer 69

C, undetermined (infinite?) output length / 62^3 67^3

l(){printf("%o",rand())-!!l&&l();}main(){srand(time(!l));l();}

l(){for(;printf("%o",rand())-!!l;l());}main(){srand(time(!l));l();}

I'd written this a few days prior, but was having a hard time figuring out the expected average length of the output. The program (given enough stack and time) eventually will terminate.

Was going to post when I figured the output length, but since Nate Eldridge's is similar, posting it now.

Originally had !'!' instead of !l; borrowed that part from Nate's answer.

I also had a similar version without srand, at 42 48 characters:

main(){printf("%o",rand())-!!'!'&&main();}

main(){for(;printf("%o",rand())-!!'!';main());}

Mine terminate (on average) earlier, compared to Nate's (10/RAND_MAX chance of popping up the stack instead of 1/RAND_MAX), but output more digits per iteration (~10.43 vs 1).

Edit: original actually terminated after RAND_MAX/20 iterations on average. Golfed too far.

Edit2: not enough rep to comment. Golfed Nate's entries below mine (64 and 44):

w(){for(printf("%o",w);rand();w());}main(){srand(time(!w));w();}

main(){for(printf("%o",'I');rand();main());}

Answer 70

Idris, score >>> g64

h:Nat->Nat
h Z=S(S Z)
h(S y)=let n=h y in hyper n n n
let x=iterate h Z in index((index$S$S$S$Z)x)x

Last line is the expression resulting in an extremely high number. I did never use exponentiation directly, since I never even called the hyper operator on level 3. The fifth element of x already results in

hyper(hyper(hyper(hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2)),hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2)),hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2))),hyper(hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2)),hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2)),hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2))),hyper(hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2)),hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2)),hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2)))),hyper(hyper(hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2)),hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2)),hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2))),hyper(hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2)),hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2)),hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2))),hyper(hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2)),hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2)),hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2)))),hyper(hyper(hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2)),hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2)),hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2))),hyper(hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2)),hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2)),hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2))),hyper(hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2)),hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2)),hyper(hyper(2,2,2),hyper(2,2,2),hyper(2,2,2)))))

because the code builds up trinary trees of hyper operators. However, the now given value will be used to index an infinite stream, such that the n-th element of that stream equals h applied n times on zero. This results in a value much larger than Graham's number.

Answer 71

Javascript, > 10³¹⁶⁴⁶⁹ ≈ 10↑↑2.740388839

(Run from the browser console to get output)

for(a="",b="￭".charCodeAt``;b--;)a+=(''+b).repeat("￭".charCodeAt``);a

Answer 72

R, 63 characters of code, 4.036242e+3699695 ≈ 10↑↑2.81744412

set.seed(T)
paste(rep(RS<-abs(.Random.seed),RS[exp(T)]),collapse="")
# the result will be 3699696 digits long
# 624 repetitions of 4036241692704834420106146035583972223....

... or you can have it printing for as long as you have time:

set.seed(T)
repeat{cat(abs(.Random.seed),sep="")}

Answer 73

Lua, Unknown/99^3 ≈ 10↑↑2.945956159

With infinite runtime:

m=math;p=m.pi;t=m.floor(p)s=tostring;h=t+s(p):sub(t)j=h;while(j>t)do io.write(s(h):rep(h))j=j-t;end

< 5 seconds:

m=math;p=m.pi;t=m.ceil(p)s=tostring;h=t+s(p):sub(-t)j=h;while(j>t)do io.write(s(h):rep(h))j=j-t;end

Ungolfed:

t=math.ceil(math.pi)                -- Acquire the number 4
h=t+tostring(math.pi):sub(-t)       -- Get the last t(4) digits of pi(5898) as a string.
                                    -- Adding t auto converts it to a number and increases our number
j=h;                                -- Set j as a counter to loop
while(j>t)do
    io.write(tostring(h):rep(h))    -- Add h(5902) repitions of h as a string to the output
    j=j-t;                          -- Decrement j by t(4), my only number available
end

Extra

Lua's lack of mathematical constants (other than pi) and ++ or -- operators made it tricky to manipulate numbers, but I thought I made good work with what I have. string.rep is the real hero.

If there's a notation that exists to write my score, I'll include it, but I don't know of one. If I was thinking correctly, the < 5 code's number should be (5902 repeated 5902 times) repeated ~5902/4 times.