编写满足以下要求的最短程序（长度以字节为单位）：

• 没有输入
• 输出到标准输出
• 执行最终终止
• 输出字节总数超过Graham的数量

假设程序运行到能够访问无限资源的理想计算机¹上的“正常”终止，并且在必要时修改了通用编程语言（无需更改语法）以允许这样做。基于这些假设，我们可以称其为Gedanken实验。

首先，这是一个73字节的Ruby程序，该程序在快速增长的层次结构中计算_{fω+ 1}（99）：

f=proc{|k,n|k>0?n.times{n=f[k-1,n]}:n+=1;n};n=99;n.times{n=f[n,n]};puts n

¹编辑：更准确地说，假设我们采用现有系统并对其进行修改，以使其对存储大小没有上限（但始终是有限的）。在指令的执行，时间不应该被修改，但该机被认为是因为它会对它的工作寿命没有上限理想。

GolfScript（49 47个字符）

4.,{\):i\.0={.0+.({<}+??\((\+.@<i*\+}{(;}if.}do

有关大量说明，请参见蠕虫的生存期。总之，这将打印数大于大于f _{ω ^ω}（2）。

哈斯克尔， _{59 57 55} 63

(f%s)1=s;(f%s)n=f.(f%s)$n-1
main=print$((flip((%3)%(3^))3)%4)66

它是如何工作的：%只需要一个函数，并在其n-1上编写时间即可s；即%3采用一个函数f并返回n等于将该函数连续应用f3 n-1次的函数。如果我们迭代此高阶函数的应用，则会得到一系列快速增长的函数-从幂运算开始，它恰好是Knuth-arrow-forest大小的序列：
((%3)%(3^))1 n = (3^)n     = 3ⁿ = 3↑n
((%3)%(3^))2 n = ((3^)%3)n = (3↑)ⁿ⁻¹ $ 3 = 3↑↑n
((%3)%(3^))3 n = (((3^)%3)%3)n = (3↑↑)ⁿ⁻¹ $ 3  = 3↑↑↑n
依此类推。((%3)%(3^))n 3是3 ↑ⁿ 3，这是计算格雷厄姆数的结果。剩下要做的就是组成函数(\n -> 3 ↑ⁿ 3) ≡ flip((%3)%(3^))3在4（计算开始的箭头数）的顶部超过64次，得到一个比Graham的数字大的数字。显然，的对数（这是一个缓慢的慢函数！）g₆₅仍大于g₆₄=G，因此，如果我们打印该数字，则输出长度将超过G。

⬛

Pyth，29 28字节

M?*GHgtGtgGtH^ThH=ZTV99=gZTZ

为超级操作定义一个lambda并递归调用它。类似于格雷厄姆数字的定义，但是值更大。

这个：

M?*GHgtGtgGtH^3hH

定义一个lambda，大致等于python

g = lambda G, H:
  g(G-1, g(G, H-1)-1) if G*H else 3^(H+1)

这给出了超运算函数，g（G，H）= 3↑ ^{G + 1}（H + 1）。
因此，例如g（1,2）= 3↑ ² 3 = 7,625,597,484,987，您可以在此处进行测试。

V<x><y>开始一个循环，执行机构，y，x倍。
=gZT是这里的循环体，相当于Z=g(Z,10)

代码：

M?*GHgtGtgGtH^3hH=Z3V64=gZ2)Z

应该递归地调用超操作64次以上，给出格雷厄姆数。

但是，在我的回答中，我将替换为T，并将其初始化为10，并将递归深度增加到99。使用Graham Array Notation，Graham的Number为[3,3,4,64]，程序输出较大的[10,11,11,99]。我还删除了)关闭循环以节省一个字节的，因此它在99次迭代中输出每个连续的值。

Python（111 + n），n =长度（x）

尽管这个程序不如Answerer的Ruby程序那么短，但我还是将其发布，以排除这种可能性。

它使用Ackermann函数，并以m和n为另一次调用Ackermann函数的值来调用Ackermann函数，然后重复执行1000次。

这可能比Graham的数字大，但我不确定，因为没人知道它的确切长度。如果不大，可以轻松扩展。

x=999
b='A('*x+'5,5'+')'*x
def A(m,n):n+1 if m==0 else A(m-1,A(m,n-1)if n>0 else 1)
exec('print A('%s,%s')'%(b,b))

Ruby，54 52 50字节

f=->b{a*=a;eval"f[b-1];"*b*a};eval"f[a];"*a=99;p a

Ruby，85 81 76 71 68 64 63 59 57字节

f=->a,b=-a{eval"a*=b<0?f[a,a]:b<1?a:f[a,b-1];"*a};p f[99]

f（a + 1）> _{fω+ 1}（a）时，等级增长非常快。

Ruby，61个字节

f=->a,b=-a{a<0?9:b==0?a*a:f[f[a-1,b],b>0?b-1:f[a,b+1]]};f[99]

基本上是带有扭曲的Ackermann函数。

Ruby，63个 59字节

n=99;(H=->a{b,*c=a;n.times{b ?H[[b-1]*n*b+c]:n+=n}})[n];p n

另一个Ruby，74 71字节

def f(a,b=a)a<0?b:b<0?f(a-1):f(a-1,f(a,b-1))end;n=99;n.times{n=f n};p n

基本上，阿克曼（Ackermann）的功能达到其自身的99倍。

的Python：85

f=lambda a,a:a*a
exec'f=lambda a,b,f=f:reduce(f,[a]*b,1)'*99
exec'f('*64+'3'+',3)'*64

也许可以缩短到74 +length(X)：

f=lambda a,a:a*a
exec'f=lambda a,b,f=f:reduce(f,[a]*b,1)'*int('9'*X)
f(3,3)

X适当的大数在哪里，使得对的超级操作3, 3大于格雷厄姆数（如果该数小于Grahams数，则将99999999999保存某个字节）。

注意：我假设python代码是在交互式解释器上执行的，因此结果将打印到stdout，否则9将为每个调用的解决方案添加字节print。

Javascript，83个字节

另一个Ackermann函数解决方案。

(function a(m,n,x){return x?a(a(m,n,x-1),n,0):(m?a(m-1,n?a(m,n-1):1):n+1)})(9,9,99)

JavaScript，68个字节，但是不适合使用ES6

a=(x,y)=>y?x?a(a(x-1,y)*9,y-1):a(9,y-1):x;b=x=>x?a(9,b(x-1)):9;b(99)

a 函数类似于以9为底的向上箭头表示法。

       /a(a(x-1,y)*9,y-1)  x>0, y>0
a(x,y)=|a(9,y-1)           x=0, y>0
       \x                  y=0

b函数是：b（x）= b ^x（9）

b(99)与Graham的数< _{fω+ 1}（64）相比，是_{〜fω+ 1}（99 ）。