您的目标是编写一个打印数字的程序。数字越大，您将获得的积分越多。不过要小心！在评分功能中，代码长度既受限制，又受权重。您的打印数量将除以用于解决方案的字节数的立方。

因此，假设您打印10000000并且代码为100字节长。您的最终成绩将是10000000 / 100^3 = 10。

为了使这一挑战更加困难，还有其他规则要遵循。

• 您不能在代码中使用数字（0123456789）；
• 您可以使用数学/物理/等。常量，但只有当他们都小于10（例如，你可以使用丕〜= 3.14，但你不能使用阿伏伽德罗常数 = 6e23）
• 允许递归，但是生成的数字必须是有限的（因此不接受无限数作为解决方案。您的程序需要正确地终止（假设无限制的时间和内存，并生成请求的输出））；
• 您不能使用运算*（乘），/（除），^（幂）或任何其他方式来表示它们（例如2 div 2，不允许）；
• 如果需要，您的程序可以输出多个数字。只有最高的一个才算得分；
• 但是，您可以串联字符串：这意味着任何相邻数字序列都将被视为一个数字；
• 您的代码将按原样运行。这意味着最终用户不能编辑任何代码行，也不能输入数字或其他任何内容。
• 最大代码长度为100个字节。

排行榜

1. 史蒂芬H.，Pyth ≈˚F _{φ（1,0,0）7}（256 ²⁶）/ 1000000 ^[1]
2. 简单地美丽的艺术，红宝石 ≈˚F _{φ 121（ω）}（126） ^[1]
3. 彼得·泰勒，GolfScript ≈˚F _{ε 0 +ω+ 1}（17）/ 1000 ^[1]
4. 水库，GolfScript ≈˚F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（126））））））））） ^[1]
5. 简单美丽的艺术，红宝石 ≈˚F _{ω ^ω2 +1}（1983）
6. eaglgenes101，朱莉娅 ≈˚F _ω3（127）
7. col6y，Python 3， ≈（127→126→...→2→1）/ 99 ^{3 [1] [3]}
8. Toeofdoom，Haskell中， ≈一个₂₀（1）/ 99 ^{3 [1]}
9. Fraxtil，直流电， ≈15↑15 15/100 ^{3 [3]}
10. 品红，Python和 ≈ACK（126126）/ 100 ³ ≈10↑ ¹²⁴ 129
11. 肯德尔弗雷，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. 递归，Python和 ≈2↑↑九十五分之一十一 ³ ≈10↑↑8.63297 ^{[1] [3]}
15. 纳米，Haskell中， ≈2↑↑一百分之七 ³ ≈10↑↑4.63297 ^[1]
16. 大卫偏航，C， ≈10 ^{10 4×10 22} /83 ³ ≈10↑↑4.11821 ^[2]
17. 普里莫，Perl中， ≈10^{（12750684161！）5×2 27} /100 ³ ≈10↑↑4.11369
18. 艺术，C， ≈10 ^{10 2×10 6} /98 ³ ≈10↑↑3.80587
19. 罗伯特Sørlie，X86， ≈10 ^{2 2 19 32} /100 ³ ≈10↑↑3.71585
20. 托比亚，APL， ≈10 ^{10 353} /100 ³ ≈10↑↑3.40616
21. 达伦石，C， ≈10 ^{10 97.61735} / 98 ³ ≈10↑↑3.29875
22. ecksemmess，C， ≈10 ^{2 320} /100 ³ ≈10↑↑3.29749
23. 亚当Speight的，vb.net， ≈10 ^{5000×（2 64）4} /100 ³ ≈10↑↑3.28039
24. 约书亚，bash中， ≈10 ^{10 15} /86 ³ ≈10↑↑3.07282

_脚注

1. ^{如果宇宙中的每个电子都是一个量子位，并且其每个叠加都可以用来存储信息（只要您实际上不需要知道所存储的信息在理论上是可能的），那么该程序就需要更多的内存。可能存在，因此无法运行-现在或将来的任何构想。如果作者打算一次打印一个大于≈3↑↑3.28的值，则适用此条件。}
2. ^{该程序需要比当前更多的内存，但理论上它并不能存储太多的量子位，因此有一天可能会存在一台可以运行该程序的计算机。}
3. ^{当前可用的所有解释器都会发出运行时错误，否则程序将无法按照作者的预期执行。}
4. ^{运行此程序将对您的系统造成无法修复的损害。}

编辑 @primo：我已经更新了计分板的一部分，使用了希望比较容易的符号，并用小数点表示到下一个更高幂的对数距离。例如10↑↑2.5 = ^{10 10√10}。如果我认为用户的分析是错误的，我也更改了一些分数，请随时对其中任何一个提出质疑。

该符号的说明：

如果0 ≤ b < 1是的话。a↑↑b = ab

如果b ≥ 1是的话。a↑↑b = aa↑↑(b-1)

如果b < 0是的话。a↑↑b = loga(a↑↑(b+1))

GolfScript；得分至少_{fε_0+ω+ 1}（17）/ 1000

在res建议使用“ 蠕虫的生存时间”来回答这个问题之后，我提出了两个程序，这些程序极大地改进了他对Howard解决方案的推导。

它们共享一个通用前缀，以函数名称为模：

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

计算g(g(1)) = g(5)，其中g(x) = worm_lifetime(x, [x])为f大致生长_{ε 0}（其水库音符是“在功能快速增长的层次结构，在大致生长的相同的速率古德斯坦功能”）。

稍微容易分析（！）的是

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

.{foo}*映射x到foo^x x。

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

因此给出g^(g(5)) ( g(5) ); 另外的8个迭代级别类似于箭头链接。为了表达简单来说：如果h_0 = g和h_{i+1} (x) = h_i^x (x)那我们算h_10 (g(5))。

我认为第二个程序几乎肯定会得分更高。这次分配给功能的标签g是换行符（原文如此）。

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

这次，我可以更好地利用它^作为其他功能。

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

需要x在栈上，并离开x随后包含字符串x的拷贝.{，随后g接着x的副本}*; 然后评估字符串。由于我有更好的刻录备用字符的地方，因此我们从开始j_0 = g；开始。如果是，j_{i+1} (x) = j_i^x (x)那么对^计算的第一次评估j_{g(5)} (g(5))（我敢肯定，它已经超过了以前的程序）。然后我再执行^16次；所以，如果k_0 = g(5)和k_{i+1} = j_{k_i} (k_i)它然后计算k_17。我再次感谢res估计k_i>> _{fε_0+ω+ 1}（i）。

Windows 2000-Windows 8（3907172 /23³= 321）

注意：请勿运行此功能！

将以下内容保存到批处理文件中，然后以管理员身份运行。

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

在4TB驱动器上运行时输出，第一个打印的数字为粗体。

为驱动器D：插入新磁盘，
并在准备好后按ENTER...。文件系统的类型为NTFS。
新文件系统为FAT。
QuickFormatting 3907172M
该卷太大，无法容纳FAT16 / 12。

GolfScript，得分：方法太多

好了，我们可以在几个字符的GolfScript中打印多少个数字？

让我们从下面的代码开始（谢谢，Ben！），该代码显示126：

'~'(

接下来，让我们重复126次，给我们一个等于大约1.26126×10 ^377的数字：

'~'(.`*

（这是字符串重复，而不是乘法，因此在规则下应该可以。）

现在，让我们将 378位数字重复10 ³⁷⁷次：

'~'(.`*.~*

你永远不会真正看到这个节目结束，因为它试图计算与约10号³⁸⁰ ≈2 ¹¹⁴⁰位。从来没有建造过的计算机可以存储这么大的数字，也不能使用已知的物理学来建造这样的计算机。将在可观测宇宙的原子数估计为约10 ⁸⁰，所以即使我们能以某种方式使用所有的物质在宇宙中存储这个庞大的数字，我们还是无论如何都必须填满约10 ³⁸⁰ /10 ⁸⁰ = 每个原子有 10 ^300个数字！

但让我们假设我们有上帝自己的GolfScript解释器，能够运行这样的计算，并且我们仍然不满意。好，让我们再做一次！

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

该程序的输出（如果可以完成的话）将具有大约10 ^{10 383}位，因此大约等于10 ^{10 10 383}。

可是等等！该程序正在变得重复...为什么我们不将其变成循环？

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

在这里，循环体运行了大约10 ³⁷⁷次，给我们提供了大约10 10 ^{× 10 377个}数字左右的理论输出，其中10的幂次幂的塔大约长10 ³⁷⁷步。（实际上，这是一个严重的低估，因为我忽略了一个事实，即重复的次数每次都会越来越长，但是相对而言，这是个小问题。）

但是我们还没有完成。让我们添加另一个循环！

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

为了甚至适当地写下这些数字的近似值，都需要深奥的数学符号。例如，使用Knuth向上箭头表示法，上面的程序输出的数字（理论上）应为10↑ ³ 10 ³⁷⁷，假设我做对了数学，则赋予或接受10的几次（或10 ³⁷⁷）次幂。

这样的数字已经超越了“难以置信的巨大”的范围，进入了“不可思议的”领域。就像这样，不仅不可能计数或写下这样的数字（在上面的第三个示例中我们已经越过了这一点），而且从字面上看，它们在抽象数学之外没有任何可想象的用途或存在。我们可以从数学公理中证明存在这样的数字，就像我们可以从GolfScript规范中证明，如果不干预现实和可用存储空间的限制，上述程序将对其进行计算），但实际上没有任何内容。我们可以使用它们以任何方式进行计数或测量的物理宇宙。

尽管如此，数学家有时还是会使用更大的数字。（理论上）计算的数字是大需要更多一点的工作-而不是只嵌套多个环路一个接一个，我们需要使用递归望远镜深度嵌套循环的。原则上，仍然应该可以编写一个简短的GolfScript程序（我希望少于100个字节）来（理论上）计算任何可用Conway链箭头表示法表示的数字；细节留作练习。;-)

JavaScript 44个字符

这似乎有点作弊：

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

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

C，得分= 10 ^{10 97.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);}

我感谢评分方面的帮助。任何见解或更正，不胜感激。这是我的方法：

n = 从1到2 ⁶⁴ -1的每个数字的串联，重复（2 ⁶⁴ -1）⁴次。首先，这是我如何估算（低）从1到2 ⁶⁴ -1（“子序列” ）的累积位数：子序列序列中的最终数字是2 ⁶⁴ -1 = 1844674407370955161520位。因此，子序列中超过90％的数字（以1.. 开头的9数字）具有19位数字。假设剩余的10％平均10位数字。不仅如此，但这对于简单的数学运算和不作弊来说还是一个较低的估计。该子序列重复（2 ⁶⁴ -1）⁴次，因此长度的Ñ将至少（0.9×（2 ⁶⁴ -1）×19 + 0.1×（2 ⁶⁴ -1）×10）×（2 ⁶⁴ -1）⁴ = 3.86613×10 ⁹⁷个数字。在下面的注释中，@primo确认n的长度为4.1433x10 ⁹⁷。因此，n本身就是该幂的10，即10 ^{10 97.61735}。

l = 98个字符的代码

得分 = n / l ³ = 10 ^{10 97.61735} / 98 ³

要求：必须在64位计算机上运行sizeof(long) == 8。Mac和Linux将做到这一点。

Python 3-99个字符-（最有可能）比Graham的数字大得多

我基于Ackermann函数的扩展提出了一个更快的增加函数。

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启发了我，但您无需查看那里即可了解我的电话号码。

这是我将在分析中使用的ackermann函数的修改版本：

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,...),...)

A上面代码中的函数在技​​术上并不相同，但实际上更强大，可以使用以下语句替换上面定义的第三行：

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

（a必须至少为1，因此必须更强）

但出于我的目的，我将假定它与较简单的方法相同，因为分析已经对Ackermann函数进行了部分分析，因此对于具有两个自变量的函数也进行了分析。

我的函数可以保证最终停止递归，因为它总是执行以下操作：删除参数，减少第一个参数，或保留相同的第一个参数并减少第二个参数。

尺寸分析

格雷厄姆的数字AFAIK可以表示为G(64)：

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

其中↑^(n)b是knuth的向上箭头表示法。

以及：

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)

上面程序中表示的数字是A(0,1,2,3,4,...,123,124,125)。

由于g^64(4)是格雷厄姆的数字，并且假设我的数学是正确的，则它小于A(1,64,100)，我的数字明显大于格雷厄姆的数字。

请指出我的数学中的任何错误-尽管如果没有错误，这应该是迄今为止为回答这个问题而计算出的最大错误数。

Perl-得分≈10↑↑4.1

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

再次滥用perl的正则表达式引擎来研磨难以想象的数量的组合，这次使用递归下降。

在表达式的最内层，我们可以.防止无限递归，从而将递归级别限制为字符串的长度。

我们最终将得到的是：

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

...重复671088640次，总共嵌套了12750684161次-这使我之前的23次嵌套尝试完全丢掉了。值得注意的是，perl甚至没有为此感到窒息（再次，内存使用量稳定地保持在1.3GB左右），尽管在发布第一个打印语句之前还需要相当长的时间。

我以前在下面的分析，可以得出结论，数字输出的数量会的量级（！12750684161）^671088640，其中！k来是左阶乘的ķ（见A003422）。我们可以将其近似为（k-1）！，它严格较小，但大小相同。

如果我们问Wolframalpha：

...这根本不会改变我的分数。我以为那肯定是至少10↑↑5。我想10↑↑4和10↑↑4.1之间的差异比您想象的要大得多。

Perl-得分≈10↑↑4

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

滥用perl regex引擎为我们做一些组合。嵌入式代码块
(??{print})会将其结果直接插入到正则表达式中。由于$_完全由2s 组成（结果print始终为1），因此它永远无法匹配，并通过所有可能的组合发送perl spin，其中有很多组合。

使用的常数

• $^F-最大系统文件句柄，通常为2。
• $]-perl版本号，类似于5.016002。

$_然后是包含2重复671088640次的数字的字符串。内存使用率恒定在1.3GB左右，立即开始输出。

分析

让我们将P _k（n）定义为执行print语句的次数，其中k是嵌套数，n是字符串的长度加一（只是因为我不喜欢写n + 1到处）。

(.*.*)*
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，... ]

通常，该公式可以归纳为以下内容：

哪里

也就是说，左阶乘的ķ，即小于所有阶乘的总和ķ（见A003422）。

我一直无法确定D _k和E _k的闭合形式，但这没什么大不了的，如果我们观察到

和

有23个嵌套，这使我们获得大约分数：

实际上，这应该几乎是准确的。

但是，为了将其表示为更易于可视化的符号，我们可以近似内部指数的基数：

然后是指数本身：

然后询问wolframalpha：

您也可以只调用10↑↑4并完成此操作。

Javascript，10↑↑↑↑210

100个字符：

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)

基于最大迭代f是最佳方法的观察，我将f嵌套的13个调用替换为3个级别的嵌套循环f，z每次调用次数（f不断增加z）。

我在一张纸上分析地估计了分数–如果有人有兴趣看到它，我会把它打出来。

提高分数：10↑↑13

再次使用正好100个字符的Javascript：

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)

这通过三种方式改善了我的原始答案：

1. 定义z全局范围使我们不必o.z每次都要键入。

2. 可以在全局范围（窗口）上定义getter并键入f而不是o.f。

3. 拥有更多的迭代f比以更大的数字开头更有价值，因此(Math.E+'').replace('.','')最好使用~~Math.E+''（= 2，11个字符）而不是（= 2718281828459045，27 个字符），并使用挽回的字符f多次调用。

因为，如下面进一步分析的那样，每次迭代都会从数量级为M的数字生成一个较大的数量级在10 ^M的数量，因此该代码会在每次迭代后生成

1. 210〜O（10 ²）
2. O（10 ^{10 2}）〜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）

得分：〜10 ^{10 10 10 10 16} ≈10↑↑6.080669764

Javascript，长度为100个字符：

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)

每个o.f调用while循环，总共5个循环。仅经过第一次迭代，分数就已经超过10 ^{42381398144233621}。在第二次迭代中，Mathematica甚至无法计算结果中的位数。

这是代码的演练：

在里面

从2718281828459045开始，方法是从中删除小数点Math.E。

迭代1

连接数字的递减顺序，

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

形成一个新的（巨大的）数字，

• 271828182845904527182818284590442718281828459043 ... 9876543210。

这个数字有几位数？好吧，这是

• 1718281828459046 16位数字
• 900000000000000 15位数字
• 90000000000000 14位数字，
• 9000000000000 13位数字
• ...
• 900个3位数字
• 90个2位数字
• 10个1位数数字

在Mathematica中

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

换句话说，它是^{2.72⋅1042381398144233625}。

仅在第一次迭代后，我的得分就达到了^{2.72⋅1042381398144233619}。

迭代2

但这仅仅是开始。现在，从巨大的数字开始，重复步骤！也就是说，将数字的递减顺序连接起来，

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

那么，我的新成绩是什么，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[]

迭代3

重复。

迭代4

重复。

迭代5

重复。

分析分数

在第一轮迭代中，我们通过计算递减序列中的位数，计算了从2718281828459045开始的递减序列的串联位数。

• 1718281828459046 16位数字
• 900000000000000 15位数字
• 90000000000000 14位数字，
• 9000000000000 13位数字
• ...
• 900个3位数字
• 90个2位数字
• 10个1位数数字

这个总和可以用公式表示，

其中ž表示起始号码（例如 2718281828459045）和ö _Ž表示其数量级（例如 15中，由于ž〜10 ¹⁵）。使用等价的有限和，以上可以明确表示为

如果我们取9≈10，则可以进一步减少到

最后，扩展项并通过减小量级对其进行排序，我们得到

现在，因为我们只是在结果的量级兴趣，让我们代替ž与“中量级一些Ø _ž ”，即 10 ^{Ø _ž} -

最后，第二项和第三项被抵消，最后两个项可以删除（它们的大小很小），使我们

从这第一届选举中胜出。

重述，f取入的数量级的数中号和在数量级大约产生数中号（10 ^中号）。

可以轻松地手动检查第一次迭代。2718281828459045是数量级为15的数字-因此f应产生数量级为15（10 ¹⁵）〜10 ^16的数字。事实上，所产生的数量是，从之前，2.72⋅10 ^{42381398144233625}，也就是说，10 ^{42381398144233625}〜10 ^{10 16}。

注意，M不是M（10 ^M）的重要因素，因此，每次迭代结果的数量级遵循简单的四元组模式：

1. 10 ¹⁶
2. 10 ^{10 16}
3. 10 ^{10 10 16}
4. 10 ^{10 10 10 16}
5. 10 ^{10 10 10 10 16}

LaTeX来源

(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}

APL，10↑↑3.4

这是我的修改尝试：

{⍞←⎕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 *程序（使用可忽略的内存量和常规的32位int变量），尽管完成将花费很长时间。

您实际上可以在APL解释器上运行它，它将开始打印数字。如果允许完成，它将打印出一个10×123456789 ⁴⁴位数字。

因此，分数是10 ^{10×123456789 44} /100 ³ ≈10 ^{10 353} ≈10↑↑3.406161

说明

• ⎕D 是等于的预定义常量字符串 '0123456789'
• n←⍎⎕D定义n为该字符串表示的数字：123456789（它是<2 ³¹，因此可以用作循环控制变量）
• {⍞←⎕D} 会将10位数字输出到标准输出，不带换行符
• {⍞←⎕D}⍣n会执行n次（⍣是“幂运算符”：既不是*，/也不是^，因为它不是数学运算，而是一种循环）
• {⍞←n}⍣n⍣n将重复先前的操作Ñ倍，因此在打印10个数字Ñ ²倍
• {⍞←n}⍣n⍣n⍣n会做n ³次
• 我可以⍣n在其中放入44 ，因此它打印的n是字符串的⁴⁴倍'0123456789'。

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
^{*：APL可以写在它自己的（传统）单字节即APL符号映射到上部128个字节值的字符集。因此，出于评分的目的，仅使用ASCII字符和APL符号的N个字符的程序可以视为N个字节长。}

Haskell，得分：（2 ^{2 2 65536} -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

该程序正好是100字节的纯Haskell代码。它将打印第四个Ackermann数，最终消耗整个宇宙以及此过程之外的所有可用能量，物质和时间（因此略超过5秒的软限制）。

Python，2↑↑11/830584≈10↑↑8.632971（Knuth向上箭头符号）

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

可能没有计算机有足够的内存来成功运行此程序，但这并不是程序的真正错误。在满足最低系统要求的情况下，它可以正常工作。

是的，这是对布尔值进行位移。 在这种情况下True被强迫1。Python具有任意长度的整数。

高尔夫Script 3.673e + 374

'~'(.`*

我认为这*是允许的，因为它表示字符串重复，而不是乘法。

说明：'~'(将在堆栈上保留126（ASCII值“〜”）。然后复制该数字，将其转换为字符串，然后重复126次字符串。这给出了126126126126...大约1.26 e+377。解决方案是7个字符，因此除以7^3，得到的分数约为3.673e+374

Ruby，概率无限，共54个字符

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

x初始化为97。然后，我们重复以下过程：生成0和1之间的x个随机数。如果它们都相同，则终止并打印x。否则，将x加倍并重复。由于Ruby的随机数的精度为17位，因此在任何一步终止的几率是（10e17）^ x中的1。因此，在n步内终止的概率是（1 / 10e17）^（2 ^ n）的x = 1至n的总和，收敛为1 / 10e34。这意味着对于任何数字，无论大小如何，该程序输出的数字都不大。

现在，当然，哲学上的问题是，是否可以说某个程序在任何n步中被步骤n终止的机会少于10 ^ 34的十分之一，就可以说它永远终止了。如果我们不仅假设无限的时间和力量，而且还假设程序具有以超过终止概率降低的速率增加的速度运行的能力，那么我相信实际上可以使在时间t处终止，任意接近1。

GolfScript，≈˚F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（126）））））））））

这是无耻地改编自 @Howard的另一个答案，并结合了@Peter Taylor的建议。

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

我对GolfScript的了解有限，但我相信 *^上面和运算符不是 OP禁止的算术运算符。

（如果@Howard想要提交自己的版本，我会很乐意将其删除，这无疑比这要好。）

此程序计算一个数字，是大约˚F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（F _{ε 0}（126）））））） ））） - f的九倍迭代_{ε 0}，其中f - _{ε 0}是在所述功能快速增长的层次结构，在大致生长的相同的速率古德斯坦功能。（F _{ε 0}生长得很快，k重康威的弗里德曼n的生长速率（k）的函数和链状箭头几乎微不足道，即使在比较只是一个单一的非迭代˚F _{ε 0}）。

dc，100个字符

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

给定足够的时间和内存，它将计算出大约15↑¹⁶⁶⁶⁶⁶⁵15的数字。我最初实现了hyperoperation函数，但此挑战需要太多字符，因此我删除了n = 2, b = 0and n >= 3, b = 0条件，将n = 1, b = 0条件转换为n >= 1, b = 0。

此处使用的唯一算术运算符是加法和减法。

编辑：正如评论中所承诺的，以下是此代码的功能细目：

[            # 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

如前所述，这与超级运算功能的区别在于，用于乘法和更高运算的基本情况被用于加法的基本情况所代替。此代码的行为就像是a*0 = a^0 = a↑0 = a↑↑0 ... = a，而不是数学上正确的a*0 = 0和a^0 = a↑0 = a↑↑0 ... = 1。结果，它计算出的值比应有的值高一点，但这并不是什么大问题，因为我们的目标是更大的数字。:)

编辑：我只是注意到在执行递增的宏中，一个数字偶然滑入了代码中n=0。我已经用“ F”（15）替换了它，删除了它，它的副作用是将每个增量操作按比例缩放15。

运行时没有更多限制了吗？好吧。

该程序是否需要在现代计算机上可运行？

两种解决方案都使用64位编译，因此long是64位整数。

C：大于10 ^{（2 64 -1）2 64}，它本身大于10 ^{10 355393490465494856447≈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个字符。

为了简化这些公式，我将使用t = 2^64-1 = 18446744073709551615。

main将f使用的参数进行调用t，这将循环t时间，每次打印该值t，然后f使用的参数进行调用t-1。

总印刷数字：20 * t。

f使用的参数进行的每个调用t-1都会迭代t时间，打印值t并使用的参数调用f t-2。

总印刷数字： 20 * (t + t*t)

我尝试使用等效于3位整数（我设置i = 8并具有main调用f(7)）的程序。它达到打印声明6725600次。这一工程出去7^8 + 7^7 + 7^6 + 7^5 + 7^4 + 7^3 + 7^2 + 7。因此，我认为，这是整个方案的最终计数：

总印刷数字： 20 * (t + t*t + t^3 + ... + t^(t-1) + t^t + t^(2^64))

我不确定如何计算（2 ⁶⁴ -1）^{2 64}。该总和小于（2 ⁶⁴）^{2 64}，我需要2的幂才能进行此计算。因此，我将计算（2 ⁶⁴）^{2 64 -1}。它比实际结果小，但是由于它是2的幂，因此我可以将其转换为10的幂，以便与其他结果进行比较。

有人知道如何执行该求和，或如何将（2 ⁶⁴ -1）^{2 64}转换为10 ⁿ吗？

20 * 2 ^ 64 ^（2 ^ 64-1）
20 * 2 ^ 64 ^ 18446744073709551615
20 * 2 ^（64 * 18446744073709551615）
20 * 2 ^ 1180591620717411303360
10 * 2 ^ 1180591620717411303361
将指数除以10的对数底数2，以将指数的底数转换为10的幂。
1180591620717411303361 / 3.321928094887362347870319429489390175864831393024580612054756 = 
355393490465494856446
10 * 10 ^ 355393490465494856446
10 ^ 355393490465494856447

但是请记住，那是打印的数字位数。整数的值是10的整数次幂，因此10 ^ 10 ^ 355393490465494856447

该程序的堆栈深度为2 ^ 64。仅用于存储循环计数器的内存为2 ^ 72字节。这就是40亿兆字节的循环计数器。更不用说在2 ^ 64级别的递归中堆栈上要进行的其他操作。

编辑：更正了两个错字，并为log2（10）使用了更精确的值。

编辑2：请稍等，我有一个循环，其中printf在外面。让我们修复它。添加了初始化i。

编辑3：搞砸了，我在上一次编辑中搞砸了数学。固定。

该程序将在现代计算机上运行，​​尽管不会很快完成。

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个字符。

对于每次迭代，这将打印零的按位倒数2 ^ 64-1。2 ^ 64-1是20位数字。

位数= 20 * (2^64-1)^7= 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187500

将程序长度四舍五入为100个字符，分数=印刷数量/ 1,000,000

分数= 10 ^ 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187494

R- 49 41个字符的代码，4.03624169270483442 * 10 ^ 5928≈10↑↑2.576681348

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

将打印出[这里只是开始复制]：

403624169270483442010614603558397222347416148937479386587122217348........

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

（3↑↑↑↑3是G（1），其中G（64）是格雷厄姆的数字）

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)

输出：10 ^ 3↑↑↑↑3

提示：

G是其中G（64）是格雷厄姆数的函数。输入是整数。输出是用0编写的一元字符串。为简洁起见，将其删除。

K是Knuth上箭头函数a↑ ⁿ b，其中a隐式为3。输入是n（一元字符串）和b（一元字符串）。输出是一元字符串。

u 是“ 1”。

v 是“ 0000”或G（0）

e 是“ 000”。

C

（对达伦·斯通表示歉意）

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

n = 2 ^ 64位数字（9 ...）

l = 100个字符的代码

分数≈1e + 2135987035920910082395021706169552114602704522356652769769947041607822219725780640550022962086936570≈10↑↑3.2974890744

[分数= n ^ 5 / l ^ 3 =（10 ^（2 ^ 320）-1）/（100 ^ 3）=（10 ^ 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576-1）/（10 ^ 6）]

请注意，我应该毫不留情地回答这个问题，但无法抗拒。由于明显的原因，我不建议在stackexchange上像我一样。:-P

编辑：更难以抵制类似的诱惑

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

...但我想有一个预定但未指定的规则是，必须打印出组成该数字的整个数字。

新的Ruby：分数〜F _{ω ^ω2 +1}（126 ² 2 ¹²⁶）

其中_fα（n）是快速增长的层次结构。

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

在线尝试！

的 *n只是字符串和数组乘法，所以他们应该罚款。

取消程式码：

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]}

其中，b.-b<=>0返回比1接近的整数。0b

说明：

n在每次调用时开始打印H。

H[[]]加倍n（n倍），即n = n<<n。

H[[0,a,b,c,...,z]]通话H[[a,b,c,...,z]]（n次）。

H[[k+1,a,b,c,...,z]]呼叫H[[k]*n+[a,b,c,...,z]]（n次），其中[k]*n = [k,k,...,k]。

H[[-1,a,b,c,...,z]]通话H[[n]*n+[a,b,c,...,z]]（n次）。

H[[-(k+1),a,b,c,...,z]]通话H[[-k]*n+[a,b,c,...,z]]（n次）。

H[k] = H[[k]]。

我的程序初始化n = 126，然后调用H[-n-1]126 ² 2 ¹²⁶次。

例子：

H[[0]]将呼叫H[[]]适用的n = n<<n（n次）。

H[[0,0]]会拨打H[[0]]（n次）。

H[[1]]会拨打H[[0]*n]（n次）。

H[[-1]]会拨打H[[n]*n]（n次）。

H[[-1,-1]]会拨打H[[n]*n+[-1]]（n次）。

H[[-3]]会拨打H[[-2]*n]（n次）。

在线尝试！

请参阅修订以了解其他有趣的内容。

Haskell-Ackermann函数对其结果应用20次-99个字符

这是我基于ackermann函数可以提出的最好的haskell解决方案-您可能会注意到与nm解决方案有一些相似之处，i = round $ log pi就是从那里启发而来的，其余都是巧合：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

它一次运行20次ackermann函数，从1开始，顺序为

• 1，
• 3，
• 61，
• 一个（61,61）
• a（a（61,61），a（61,61））-我们将其称为₂（61）或₄（1）-
• 一个₃（61）
• ...
• 一个₁₈（61），或₂₀（1）。我认为这大约是g ₁₈（请参阅下文）。

至于估计，维基百科说：

a（m，n）= 2↑ ^m-2（n + 3）-3

从中我们可以看到a3（1）= a（61,61）= 2↑ ⁵⁹ 64 + 3，这显然大于g1 = 3↑ ⁴ 3，除非开始时的3比我想的重要得多。之后，每个级别执行以下操作（丢弃_n中的无关紧要的常量）：

• g _n = 3↑ ^{g _n-1} 3
• a _n〜 = 2↑ ^{a _n-1}（a _n-1）

如果这些近似相等，则₂₀（1）〜= g ₁₈。_n（a _n-1）中的最后一项远大于3，因此它可能比g _18高。我将查看是否可以确定是否即使一次迭代也能提高效率并进行报告。

x86机器代码-100字节（汇编为MSDOS .com文件）

注意：可能会稍微改变规则

该程序将输出2 ^{（65536 * 8 + 32）个} 9，这将使分数为 （10 ^{2 524320} -1）/ 1000000

作为计数器，该程序使用整个堆栈（64kiB）加上两个16位寄存器

汇编代码：

8A3E61018CD289166101892663018ED331E4BB3A01438A2627
018827A0300130E4FEC4FEC4FEC410E4FEC400E431C95139CC
75FB31D231C931DBCD3F4175F94275F45941750839D4740D59
4174F85131C939D475F9EBDD8B266301A161018ED0C3535858

部件：

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'

C

文件大小为45个字节。

该程序是：

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

并且产生的数字大于10 ^（10 ^（10 ^ 1.305451600608433））。

我将std重定向到的文件当前超过16 Gb，并且仍在增长。

如果我有一台更好的计算机，该程序将在合理的时间内终止。

对于双精度浮点数，我的分数无可争议。

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。SHLVL是一个小的正整数（通常为1或2，具体取决于/ bin / sh是否为bash）。

仅64位UNIX：

得分：〜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'

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];);}

我们创建一个258048个无符号整数的数组。它不能是无符号的long，因为这会使程序太长。它们是未签名的，因为我不想使用未定义的行为，此代码是正确的C语言（除了缺少main（）的返回值之外），并且可以在任何普通计算机上编译和运行，但是尽管如此，它仍可以运行很长时间。这个大小是我们在不使用非ASCII字符的情况下可以合法表示的最大大小。

我们从最后一个元素开始遍历数组。2^32-1如果元素未包装为0，我们将打印的数字，增加元素并放下循环。这样，我们将循环循环(2^32 - 1)^254048 = 2^8257536，每次打印10位数字。

以下示例代码在更有限的数据范围内显示了原理：

#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");
        }
}

结果大约是10 ^ 10 ^ 2485766除以一百万，仍然是大约10 ^ 10 ^ 2485766。

Powershell（2.53e107976 /72³= 6.78e107970≈10↑↑1.701853371）

这需要5秒钟以上的时间才能运行。

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

它检索并连接当前驱动器上每个文件的字节长度。正则表达式会去除所有非数字字符。

Python 3，得分= 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))

f函数是ackermann函数，我有足够的空间来调用。

编辑：以前是“ else n + 1”，这违反了挑战规则，对“简单美丽的艺术”表示敬意。

JavaScript 98个字符

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)

产生2.718e + 239622337≈10↑↑2.9232195202

得分略高于2.718e + 239622331≈10↑↑2.9232195197

这是我可以做到的最大规模，而不会导致浏览器崩溃。

（console.log（a）将显示完整的输出）

不要运行这些：

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)

将输出2.718 + e121333054704≈10↑↑3.0189898069（aka 2.718 * 10 ^（1.213 * 10 ^ 12）与更长的答案进行比较：

更极端的版本，如果它没有使您的浏览器崩溃：（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)

这将创建与e * 10 ^（10 ^ 19）≈10↑↑3.106786869689相同大小的数字

编辑：更新的代码原始解决方案仅生成2.718e + 464

Python 3：98个字符，≈10↑↑256

使用变量参数函数：

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

有效地，E减少第一个参数，同时增加其余参数，除了在参数中放入-1而不是在参数中放-1。由于每个循环都会减少第一个自变量或减少自变量的数量，因此可以保证终止。使用的增加函数为int（“％d％d”％（k，k）），其结果在k ** 2 + 2 * k和10 * k ** 2 + k之间。我的代码确实使用*符号-但不作为乘法。它用于处理可变数量的参数，我认为应该遵循规则，因为规则的重点是限制特定的操作，而不是符号本身。

E快速变大的一些示例：

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)

在合理的时间内，只有前两个可以在我的计算机上运行。

然后，通过E(*range(ord('~')))- 调用E，这意味着：

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

我不完全确定这有多大（我一直试图将其近似为无用）-但很明显，它确实很大。

例如，大约十二个周期，结果大约是：（技术上要多一点）

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)

结果估计：

如果我们lambda k: 10 * k**2用来近似增加步长，则该函数可描述为

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₁²ⁿ), ... )

我们在这里要做的相关事情是建立10的幂的塔，因此最终得分可以近似为10↑↑256。

更好的（尽管是部分的）结果估计：

这10 * k**2与其他估计相同。

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))

根据先前的估计，它将是：

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

它大大小于实际值，因为它使用a**2而不是2**a10并使用a*2而不是2**ab。

C（分数≈10 ^ 20 000000000≈10↑↑3.005558275）

• 约20 GB输出
• 41个字符（41 ^ 3没什么意思）

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

尽管rand()输出是确定性的，因为没有种子函数。