Rust, score \$2 \uparrow\uparrow\uparrow 126\$

fn main(){let b='~' as usize;let mut n=b+b;for _ in b..n{n<<=n;for _ in b..n{n<<=n;print!("{}",n)}}}

Try it online!

Note that the code's validity is dependent on the assumption that a computer with infinite memory will have an arbitrary precision pointer to index the infinite memory. I also attempted to write a version that wouldn't overflow instantly with arbitrary precision integers but it still overflowed on the second bitshift.

Size analysis:

A bit-shifting \$n\$ leftward \$n\$ times is equivalent to the function \$n2^n = f_2(n)\$. My code applies recursion in a manner consistent with the fast-growing hierarchy to achieve \$f_4(n)\$. let the final value of the local variable n in my code above be denoted as \$o\$. It will require \$log(o)\$ bitshifts to create \$o\$. The print! statement runs every time the inner bitshift does, meaning the order of magnitude of my score is the sum of the change in the order of magnitude of the variable n between the inner bitshifts. The order of magnitude of n should be growing exponentially since it is being tetrated, so the expression for the order of magnitude of the result is $$\sum_i^{log(o)}2^i$$ telling us that the final number is \$10^{2^{log(o)+1}-1}\$ which is not meaningfully different from \$o\$ itself since \$o\$ in this case is \$f_4(126)\$ or \$10 \uparrow\uparrow\uparrow 127\$. Please let me know if this explanation seems wrong or incomplete because I am new to the domain of big numbers.

Edit: better approximation thanks to Simply Beautiful Art.

Rust, score \$10 \uparrow\uparrow\uparrow 127\$

fn main(){let b='~' as usize;let mut n=b+b;for _ in b..n{n<<=n;for _ in b..n{n<<=n;print!("{}",n)}}}

Try it online!

Note that the code's validity is dependent on the assumption that a computer with infinite memory will have an arbitrary precision pointer to index the infinite memory. I also attempted to write a version that wouldn't overflow instantly with arbitrary precision integers but it still overflowed on the second bitshift.

Size analysis:

A bit-shifting \$n\$ leftward \$n\$ times is equivalent to the function \$n2^n = f_2(n)\$. My code applies recursion in a manner consistent with the fast-growing hierarchy to achieve \$f_4(n)\$. let the final value of the local variable n in my code above be denoted as \$o\$. It will require \$log(o)\$ bitshifts to create \$o\$. The print! statement runs every time the inner bitshift does, meaning the order of magnitude of my score is the sum of the change in the order of magnitude of the variable n between the inner bitshifts. The order of magnitude of n should be growing exponentially since it is being tetrated, so the expression for the order of magnitude of the result is $$\sum_i^{log(o)}2^i$$ telling us that the final number is \$10^{2^{log(o)+1}-1}\$ which is not meaningfully different from \$o\$ itself since \$o\$ in this case is \$f_4(126)\$ or \$10 \uparrow\uparrow\uparrow 127\$. Please let me know if this explanation seems wrong or incomplete because I am new to the domain of big numbers.

Edit: better approximation thanks to Simply Beautiful Art.

Rust, score \$2 \uparrow\uparrow\uparrow 126\$

fn main(){let b='~' as usize;let mut n=b+b;for _ in b..n{n<<=n;for _ in b..n{n<<=n;print!("{}",n)}}}

Try it online!

Note that the code's validity is dependent on the assumption that a computer with infinite memory will have an arbitrary precision pointer to index the infinite memory. I also attempted to write a version that wouldn't overflow instantly with arbitrary precision integers but it still overflowed on the second bitshift.

Size analysis:

A bit-shifting \$n\$ leftward \$n\$ times is equivalent to the function \$n2^n = f_2(n)\$. My code applies recursion in a manner consistent with the fast-growing hierarchy to achieve \$f_4(n)\$. let the final value of the local variable n in my code above be denoted as \$o\$. It will require \$log(o)\$ bitshifts to create \$o\$. The print! statement runs every time the inner bitshift does, meaning the order of magnitude of my score is the sum of the change in the order of magnitude of the variable n between the inner bitshifts. The order of magnitude of n should be growing exponentially since it is being tetrated, so the expression for the order of magnitude of the result is $$\sum_i^{log(o)}2^i$$ telling us that the final number is \$10^{2^{log(o)+1}-1}\$ which is not meaningfully different from \$o\$ itself since \$o\$ in this case is \$f_4(126)\$ or \$2 \uparrow\uparrow\uparrow 126\$. Please let me know if this explanation seems wrong or incomplete because I am new to the domain of big numbers.

Rust, score \$2 \uparrow\uparrow\uparrow 126\$

fn main(){let b='~' as usize;let mut n=b+b;for _ in b..n{n<<=n;for _ in b..n{n<<=n;print!("{}",n)}}}

Try it online!

Note that the code's validity is dependent on the assumption that a computer with infinite memory will have an arbitrary precision pointer to index the infinite memory. I also attempted to write a version that wouldn't overflow instantly with arbitrary precision integers but it still overflowed on the second bitshift.

Size analysis:

A bit-shifting \$n\$ leftward \$n\$ times is equivalent to the function \$n2^n = f_2(n)\$. My code applies recursion in a manner consistent with the fast-growing hierarchy to achieve \$f_4(n)\$. let the final value of the local variable n in my code above be denoted as \$o\$. It will require \$log(o)\$ bitshifts to create \$o\$. The print! statement runs every time the inner bitshift does, meaning the order of magnitude of my score is the sum of the change in the order of magnitude of the variable n between the inner bitshifts. The order of magnitude of n should be growing exponentially since it is being tetrated, so the expression for the order of magnitude of the result is $$\sum_i^{log(o)}2^i$$ telling us that the final number is \$10^{2^{log(o)+1}-1}\$ which is not meaningfully different from \$o\$ itself since \$o\$ in this case is \$f_4(126)\$ or \$10 \uparrow\uparrow\uparrow 127\$. Please let me know if this explanation seems wrong or incomplete because I am new to the domain of big numbers.

Edit: better approximation thanks to Simply Beautiful Art.

Rust, score \$>f_4(126) / 100^3\$

fn main(){let b='~' as usize;let mut n=b+b;for _ in b..n{n<<=n;for _ in b..n{n<<=n;print!("{}",n)}}}

Try it online!

Note that the code's validity is dependent on the assumption that a computer with infinite memory will have an arbitrary precision pointer to index the infinite memory. I also attempted to write a version that wouldn't overflow instantly with arbitrary precision integers but it still overflowed on the second bitshift.

(Incomplete) Size analysis:

The size of \$n\$, the final output of the code, it has \$f_4(126)\$ as a lower bound because the bitshifts are equivalent to \$f_2(n)\$ and are recursively applied like in the fast growing hierarchy. However, I do not have the faintest clue how to calculate the actual output, since it is the result of concatenating every value of \$n\$ that passes through the inner loop. For now, I'll just list my score as \$>f_4(126)/100^3\$ until I can come up with better bounds.

Rust, score \$2 \uparrow\uparrow\uparrow 126\$

fn main(){let b='~' as usize;let mut n=b+b;for _ in b..n{n<<=n;for _ in b..n{n<<=n;print!("{}",n)}}}

Try it online!

Note that the code's validity is dependent on the assumption that a computer with infinite memory will have an arbitrary precision pointer to index the infinite memory. I also attempted to write a version that wouldn't overflow instantly with arbitrary precision integers but it still overflowed on the second bitshift.

Size analysis:

A bit-shifting \$n\$ leftward \$n\$ times is equivalent to the function \$n2^n = f_2(n)\$. My code applies recursion in a manner consistent with the fast-growing hierarchy to achieve \$f_4(n)\$. let the final value of the local variable n in my code above be denoted as \$o\$. It will require \$log(o)\$ bitshifts to create \$o\$. The print! statement runs every time the inner bitshift does, meaning the order of magnitude of my score is the sum of the change in the order of magnitude of the variable n between the inner bitshifts. The order of magnitude of n should be growing exponentially since it is being tetrated, so the expression for the order of magnitude of the result is $$\sum_i^{log(o)}2^i$$ telling us that the final number is \$10^{2^{log(o)+1}-1}\$ which is not meaningfully different from \$o\$ itself since \$o\$ in this case is \$f_4(126)\$ or \$2 \uparrow\uparrow\uparrow 126\$. Please let me know if this explanation seems wrong or incomplete because I am new to the domain of big numbers.