函数TREE（k）给出树的最长序列T ₁，T ₂，... 的长度，其中每个顶点都用k种颜色之一标记，树T _i最多具有i个顶点，没有树是a 序列中紧随其后的任何树的未成年人。

TREE（1）= 1，例如T ₁ = (1)。

TREE（2）= 3：例如T ₁ = (1); T ₂ = (2)--(2)；T ₃＝(2)。

TREE（3）很大。甚至比格雷厄姆的数字还要大。您的工作是输出一个甚至更大的数字！

这是一个代码问题，因此目标是用确定性输出大于或等于TREE（3）的任何语言（向标准输出）编写最短的程序。

• 您不允许输入。
• 您的程序最终必须终止，但是您可以假定计算机具有无限的内存。
• 您可能会假设您的语言的数字类型可以包含任何有限值，但是需要解释一下它在您的语言中的确切工作方式（例如：浮点数具有无限精度吗？）
  • 不允许将无穷大作为输出。
  • 数字类型的下溢引发异常。它不会环绕。
• 由于树（3）是一个复杂的号码，你可以使用快速增长的层次逼近˚F _{θ（Ω ^ω ω）+1}（3）作为数字击败。
• 您需要提供一个解释，说明为什么您的人数如此之大以及代码的版本是否过高，以检查您的解决方案是否有效（因为没有计算机具有足够的内存来存储TREE（3））

注意：此处当前找不到答案。

为什么TREE（3）这么大？

新的Ruby，135个字节，>> H _{ψ（φ 3（Ω+ 1））}（9）

其中H是Hardy层次结构，ψ是Madore OCF的扩展版本（将在下面说明），φ是Veblen函数。

在线尝试！

f=->a,n,b=a{c,d,e=a;a==c ?a-1:e ?a==a-[0]?[[c,d,f[e,n,b]],d-1,c]:c:[n<1||c==0?n:[f[c||b,n-1]],n,n]};h=[],k=9,k;h=f[h,p(k*=k)]while h!=0

Ungolfed ：（使用函数，而不是lambdas）

def f(a,n,b)
  c,d,e = a
  if a == c
    return a-1
  elsif e
    if a == a-[0]
      return [[c,d,f(e,n,b)],d-1,c]
    else
      return c
    end
  else
    x = c || b
    if n < 1 || c == 0
      return [n,n,n]
    else
      return [f(x,n-1,x),n,n]
    end
  end
end

k = 9
h = [[],k,k]
while (h != 0) do
  k *= k
  p k
  h = f(h,k,h)
end

Madore扩展的OCF：

和（粗略地）Veblen的phi函数：

没有常规的解释：

f(a,n,b) reduces an array recursively. (if no third argument given, it takes the first argument twice.)
f(k,n,b) = k-1, k is a positive int.
f([c,d,0],n,b) = f([c,0,e],n,b) = c
f([c,d,e],n,b) = [[c,d,f(e,n,b)],d-1,c], d ≠ -1 and c ≠ 0

f([a],0,b) = [0,0,0]
f([0],n,b) = [n,n,n]
f([],n,b) = f([b],n,b)
f([a],n,b) = [f[a,n-1,a],n,n]

我的程序启动k = 9, h = [[],9,9]。然后应用k = k*k，h = f(h,k)直到h == 0和输出k。

普通解释：

Ordinals follow the following representation: n, [], [a], [a,b,c], where n,d is a natural number and a,c are all ordinals.
x = Ord(y) if y is the syntactic version of x.
a[n,b] = Ord(f(a,n))
ω = Ord([0]) = Ord(f([a],-1,b))
n = Ord(n)
Ω = Ord([])
ψ'(a) = Ord([a])
ψ'(a)[n] = Ord(f([a],n))
φ(b,c) ≈ Ord([[0],b,c])
a(↓b)c = Ord([a,b,c]) (down-arrows/backwards associative hyper operators I designed just for ordinals)

We follow the following FS for our ordinals:
k[n,b] = k-1, k < ω
ω[n,b] = n(↓n)n
(a(↓b)0)[n,b] = (a(↓0)c)[n,b] = a
(a(↓b)c)[n,b] = (a(↓b)(c[n,b]))(↓b[n,b])a, b ≥ 0 and c > 0.
ψ'(a)[0,b] = 0(↓0)0
ψ'(a)[n,b] = (ψ'(a[n-1,a]))(↓n)ω, a > 0 and n ≥ 0. (also note that we've changed from [n,b] to [n,a].)
Ω[n,b] = ψ'(b)[n,b]

ψ'（ω∙α）≈ψ（α），上图描述的有序折叠函数。

我的计划或多或少发起k = 9和h = Ω(↑9)9，然后应用k ← k²并h ← h[k,h]直至h = 1返回k。

所以，如果我没这个权利，[[],9,9]比巴赫曼-霍华德序ψ（Ω方式做大^{Ω Ω ...}），这比θ方式大（Ω ^ω ω）+1。

ψ（Ω（↓9）9）>ψ（Ω（↓4）3）>ψ（Ω ^{Ω Ω}）1>ψ（Ω ^{Ω ω ω}）1>θ（Ω ^ω ω）+1

如果我的分析是正确的，那么我们就应该有ψ'（Ω ^Ω ∙X）〜=ψ*（Ω ^Ω ∙x），其中ψ*是正常的马度尔的PSI的功能。如果成立的话，我的顺序是大约ψ*（φ ₃（Ω+ω））。

老红宝石，309个字节，H _{ψ” 0（Ω 9）}（9）（参见修订历史记录，除了新的一个是更好的方式）

Haskell，252字节，TREE（3）+1

data T=T[T]Int
l(T n _)=1+sum(l<$>n)
a@(T n c)#T m d=any(a#)m||c==d&&n!m
l@(x:t)!(y:u)=l!u||x#y&&t!u
x!_=null x
a n=do x<-[1..n];T<$>mapM(\_->a$n-1)[2..x]<*>[1..3]
s 0=[[]]
s n=[t:p|p<-s$n-1,t<-a n,(l t<=n)>any(#t)p]
main=print$[x|x<-[0..],null$s x]!!0

感谢H.PWiz，Laikoni和ØrjanJohansen提供的帮助，以帮助您完善代码！

如HyperNeutrino所建议，我的程序精确地输出TREE（3）+1（事实证明TREE是可计算的）。

T n c是一棵带有标签c和节点的树n。c应该是1，2或3。

l t是树中节点的数量t。

t1 # t2如果t1同胚嵌入t2（基于此处的定义4.4），则为true；否则为false。

a n输出大量树木。确切的列表并不重要。的重要特性是a n包含每一个树高达n节点，用加有节点1，2或者3，也许有些多的树木，以及（但与其他树木也将被标记1，2或3）。还保证输出有限列表。

s n列出所有序列n树的长度，以使该序列的反向（因为我们向后构建）是有效的。如果第n个元素（我们从1开始计数）最多具有n个节点，并且没有树同胚地嵌入到后面的树中，则序列是有效的。

main打印出最小n的长度，以确保没有有效的长度序列n。

因为TREE(3)被定义为最长有效序列的长度，所以它是TREE(3)+1最小的n，因此没有有效长度的序列n，这是我的程序输出的结果。

Python 2中，194个字节， - H _{ψ（Ω ^{Ω Ω}）}（9）

其中H是Hardy层次结构，ψ是Pohlers定义的Bachmann-Howard序数以下的序数折叠函数。

感谢Jonathan Frech提供了-3个字节。

def S（T）：如果T == 1else [S（T [0]）] + T [1：]，则返回0
def R（T）：U = T [0]; V = T [1：]; exec“ global B; B = T” *（T [-1] == 0）; return [S（B）] +如果U == 1else [R（U）] * c + V，则V，如果U否则V
A = [[[1,1]，1]，0]
c = 9
而A：A = R（A）; c * = c
打印c

在线尝试！

间距更好的版本：

定义S（T）：
  如果T == 1，则返回0，否则[S（T [0]）] + T [1：]

定义R（T）：
  U = T [0]
  V = T [1：]
  全球B
  如果T [-1] == 0：
    B = T
  如果U == 1： 
    返回[S（B）] + V
  如果U否则返回[R（U）] * c + V

A = [[[1,1]，1]，0]
c = 9
而A：
  A = R（A）
  c * = c
打印c

说明：

该程序实现了Buchholz hydra的一种变体，仅使用0和1的标签。基本上，在每一步中，我们查看树的第一个叶节点，并查看其是否被标记为0或1。

-如果叶节点标记为0，则我们删除叶节点，然后从叶节点的父节点开始复制树c次，所有副本都连接到叶节点的祖父母。

-如果叶节点标记为1，则我们向根进行搜索，直到到达标记为0的祖先节点。令S为从该祖先节点开始的树。令S'为S，叶节点重新标记为0。用S'替换叶节点。

然后，我们重复该过程，直到除根节点之外别无其他。

该程序在两个方面与正常的Buchholz hydra过程不同：首先，在完成上述过程之后，我们递归回树，并对原始叶节点的每个祖先节点执行上述的label 0复制过程。这增加了树的大小，因此我们的过程将比正常的Buchholz hydra花更长的时间，因此最终导致更大的数目。但是，它仍然会终止，因为与新树关联的序数仍将小于旧树。另一个区别是，我们不是从c = 1开始并每次增加1，而是从c = 9开始并每次对其求平方，因为为什么不这样做。

树[[[1,1]，1]，0]对应于序ψ（Ω ^{Ω Ω}），其比序θ相当大（Ω ^ω ω），并且因此我们得到的有关H的最后数_{ψ （Ω ^{Ω Ω}）}（9）肯定会超过TREE（3）。

红宝石，140个字节， - H _{ψ（Ω ^{Ω Ω}）}（81）

其中ħ是哈代层次结构，并且ψ是巴赫曼-霍华德序低于标准序折叠功能，限定在这里。

s=->t{*v,u=t;t==1?[]:v<<s[u]}
r=->t{*v,u=t;$b=t[0][0]?$b:t;u==1?v<<s[$b]:u[0]?v+[r[u]]*$c:v}
$c=9
a=[],[1,[1,1]]
($c*=9;a=r[a])while a[0]
$c

在线尝试！

非高尔夫版本：

定义S（a）
  * v，u = a
  如果a == 1 
    返回[]
  其他
    返回v + [S（u）]
  结束
结束  

定义R（t）
  * v，u = t
  如果t [0] == []
    $ b = t
  结束
  如果u == 1
    返回v + [S（$ b）]
  elsif u == []
    返回v
  其他
    返回v + [R（u）] * $ c
  结束
结束

$ c = 9

a = [[]，[1，[1,1]]]

当！= []做
  $ c * = 9
  a = R（a）
结束

打印$ c

如我的Python 2条目中所述，该程序实现带有标记为[]和1的节点的Buchholz hydra。

树[[]，[1，[1,1]]]对应于序ψ（Ω ^{Ω Ω}），其比序θ（Ω相当大^ω ω）=ψ（Ω ^{Ω ω ω}），和所以我们得到的有关H的最后数_{ψ（Ω ^{Ω Ω}）}（81）将超过TREE（3）。

朱莉娅，569字节，装载者编号

r,/,a=0,div,0;¬x=x/2;r<s=r?s:0;y\x=y-~y<<x;+x=global r=(x%2!=0)<1+(+¬x);!x=¬x>>+x;√x=S(4,13,-4,x);S(v,y,c,t)=(!t;f=x=r;f!=2?f>2?f!=v?t-(f>v)%2*c:y:f\(S(v,y,c,!x)\S(v+2,t=√y,c,+x)):S(v,y,c,!x)$S(v,y,c,+x));y$x=!y!=1?5<<y\x:S(4,x,4,+r);D(x)=(c=0;t=7;u=14;while(x!=0&&D(x-1);(x=¬x)%2!=0)d=!!D(x);f=!r;x=!r;c==r<((!u!=0||!r!=f||(x=¬x)%2!=0)<(u=S(4,d,4,r);t=t$d);¬f&(x=¬x)%2!=0<(c=d\c;t=√t;u=√u));(c!=0&&(x=¬x)%2!=0)<(t=((~u&2|(x=¬x)%2!=0)<(u=1<<(!c\u)))\(!c\t);c=r);¬u&(x=¬x)%2!=0<(c=t\c;u=√t;t=9)end;global a=(t\(u\(x\c)))\a);D(D(D(D(D(BigInt(99))))))

为了节省一些时间，我决定将Loader.c几乎一对一地移植到Julia中，并将其压缩到上面的代码块中。对于那些想要自己进行比较（以验证我的得分或帮助我发现错误或改进我的代码）的人，下面是一个非高尔夫版本：

r,/,a=0,div,0;
¬x=x/2;
r<s=r?s:0;
y\x=y-~y<<x;
+x=global r=(x%2!=0)<1+(+¬x);
!x=¬x>>+x;
√x=S(4,13,-4,x);
S(v,y,c,t)=(
    !t;
    f=x=r;
    f!=2?
        f>2?
            f!=v?
                t-(f>v)%2*c
                :y
            :f\(S(v,y,c,!x)\S(v+2,t=√y,c,+x))
        :S(v,y,c,!x)$S(v,y,c,+x)
);
y$x=!y!=1?5<<y\x:S(4,x,4,+r);
D(x)=(
    c=0;
    t=7;
    u=14;
    while(x!=0&&D(x-1);(x=¬x)%2!=0) 
        d=!!D(x);
        f=!r;
        x=!r;
        c==r<(
            (!u!=0||!r!=f||(x=¬x)%2!=0)<(
                u=S(4,d,4,r);
                t=t$d
            );
            ¬f&(x=¬x)%2!=0<(
                c=d\c;
                t=√t;
                u=√u
            )
        );
        (c!=0&&(x=¬x)%2!=0)<(
            t=((~u&2|(x=¬x)%2!=0)<(u=1<<(!c\u)))\(!c\t);
            c=r
        );
        ¬u&(x=¬x)%2!=0<(
            c=t\c;
            u=√t;
            t=9
        )
    end;
    global a=(t\(u\(x\c)))\a
);
D(D(D(D(D(BigInt(99))))))

没有以前的计数，因为我在激进的高尔夫球中犯了太多字节错误。

JavaScript，190B，_{Hψ（εΩ + 1）}（9）_{基于此分析}

A=[0,1,2];B=[0,1,2];for(F=C=9;F;F--){for(C++,G=0;G<=F;G++)(A[F]||A[F-G]<A[F]-H)&&(B[F]?(I=G,G=F):(H=A[F]-A[F-G],B[F-G]<B[F]&&(I=G,G=F)));for(J=0;J<C*I;J++)A[F]=A[F-I]+H,B[F]=B[F-I],F++;H=0}C

该程序是JavaScript中225B对序列号转换的修改版本。有关配对序列号及其原始代码，请参见此处。

所做的修改：

• 它使用JavaScript而不是BASIC。
• 无迭代（_{fψ（Ωω +1）} -> _{fψ（Ωω）}）
• 序列为（0,0）（1,1）（2,2），对应于序数ψ（εΩ _{+ 1}）。_{这是在Hardy阶层序数中}