Hàm TREE (k) cho chiều dài của dãy cây dài nhất T ₁ , T ₂ , ... trong đó mỗi đỉnh được gắn nhãn với một trong các màu k, cây T _i có nhiều nhất là i và không có cây nào là nhỏ của bất kỳ cây theo sau nó trong chuỗi.

TREE (1) = 1, ví dụ T ₁ = (1).

TREE (2) = 3: ví dụ T ₁ = (1); T ₂ = (2)--(2); T ₃ = (2).

TREE (3) là một con số lớn . Thậm chí còn lớn hơn số của Graham. Công việc của bạn là đầu ra một con số thậm chí còn lớn hơn nó!

Đây là một môn đánh gôn, vì vậy mục tiêu là viết chương trình ngắn nhất bằng bất kỳ ngôn ngữ nào xác định đầu ra một số lớn hơn hoặc bằng TREE (3) (theo thiết bị xuất chuẩn).

• Bạn không được phép lấy đầu vào.
• Chương trình của bạn cuối cùng phải chấm dứt nhưng bạn có thể giả sử máy có bộ nhớ vô hạn.
• Bạn có thể cho rằng loại số ngôn ngữ của bạn có thể giữ bất kỳ giá trị hữu hạn nào nhưng cần giải thích chính xác cách thức hoạt động của ngôn ngữ này (ví dụ: một số float có độ chính xác vô hạn?)
  • Infinities không được phép là đầu ra.
  • Dòng dưới của một loại số ném một ngoại lệ. Nó không quấn quanh.
• Bởi vì TREE (3) là một số phức tạp như vậy, bạn có thể sử dụng hệ thống phân cấp ngày càng tăng nhanh xấp xỉ f _{θ (Ohm ^w w) 1} (3) là số để đánh bại.
• Bạn cần đưa ra lời giải thích về lý do tại sao số của bạn quá lớn và phiên bản mã không được mã hóa để kiểm tra xem giải pháp của bạn có hợp lệ không (vì không có máy tính nào có đủ bộ nhớ để lưu TREE (3) )

Lưu ý: Không có câu trả lời hiện đang tìm thấy ở đây làm việc.

Tại sao TREE (3) lại lớn như vậy?

Ruby mới, 135 byte, >> H _{( 3 (Ω + 1))} (9)

nơi H là hệ thống phân cấp Hardy, ψ là một phiên bản mở rộng của OCF Madore của (sẽ giải thích dưới đây) và φ là hàm Veblen.

Hãy thử trực tuyến!

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: (sử dụng chức năng, không phải 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

OCF mở rộng của Madore:

Và (thô sơ) Hàm phi của Veblen:

Giải thích mà không có chức vụ:

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]

Chương trình của tôi bắt đầu k = 9, h = [[],9,9]. Sau đó, nó áp dụng k = k*kvà h = f(h,k)cho đến khi h == 0và đầu ra k.

Giải thích với các chức vụ:

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]

ψ '(ω ∙ α) ≈ (α), hàm thu gọn thứ tự được mô tả trong hình trên.

Chương trình của tôi ít nhiều bắt đầu k = 9và h = Ω(↑9)9sau đó áp dụng k ← k²và h ← h[k,h]cho đến khi h = 1và trở lại k.

Và vì vậy nếu tôi đã làm điều này đúng, [[],9,9]là cách lớn hơn Bachmann-Howard thứ ψ (Ohm ^{Ohm Ohm ...} ), đó là cách lớn hơn θ (Ohm ^w w) +1.

ψ (Ω (↓ 9) 9)> ψ (Ω (↓ 4) 3)> ψ (Ω ^{Ω Ω} ) +1> ψ (Ω ^{Ω w w} ) +1> θ (Ω ^w w) +1

Và nếu phân tích của tôi là chính xác, thì chúng ta nên có ψ '(Ω ^Ω ∙ x) ~ = ψ * (Ω ^Ω x), trong đó ψ * là hàm psi của Madore bình thường. Nếu cái này giữ, thì thứ tự của tôi xấp xỉ ψ * ( ₃ (Ω + ω)).

Ruby cũ, 309 byte, H _{ψ ' 0 ( 9 )} (9) (xem lịch sử sửa đổi , bên cạnh lịch sử mới là cách tốt hơn)

Haskell, 252 byte, 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

Cảm ơn sự giúp đỡ từ H.PWiz, Laikoni và Ørjan Johansen vì đã giúp đánh gôn!

Theo đề xuất của HyperNeutrino , chương trình của tôi xuất ra TREE (3) +1, chính xác (TREE có thể tính toán được khi nó bật ra).

T n clà một cây có nhãn cvà nút n. cnên 1, 2hoặc 3.

l tlà số lượng nút trong một cây t.

t1 # t2là đúng nếu t1nhúng đồng nhất vào t2(dựa trên Định nghĩa 4.4 ở đây ) và sai khác.

a nđưa ra một danh sách lớn các cây. Danh sách chính xác không quan trọng. Thuộc tính quan trọng là a nchứa mỗi cây lên đến nnút, với các nút được gắn nhãn với 1, 2hay 3, và có thể một số cây hơn là tốt (nhưng những cây khác cũng sẽ được dán nhãn với 1, 2hoặc 3). Nó cũng được đảm bảo để đưa ra một danh sách hữu hạn.

s nliệt kê tất cả các chiều dài chuỗi ncây, sao cho ngược lại (vì chúng ta xây dựng ngược) của chuỗi đó là hợp lệ. Một chuỗi là hợp lệ nếu phần tử thứ n (nơi chúng ta bắt đầu đếm ở 1) có nhiều nhất n nút và không có cây nào được nhúng đồng nhất vào một nút sau.

mainin ra nhỏ nhất nsao cho không có chuỗi độ dài hợp lệ n.

Vì TREE(3)được định nghĩa là độ dài của chuỗi hợp lệ dài nhất, TREE(3)+1là nhỏ nhất nsao cho không có chuỗi độ dài hợp lệ n, đó là những gì chương trình của tôi đưa ra.

Python 2, 194 byte, ~ H _{(Ω ^{Ω Ω} )} (9)

nơi H là hệ thống phân cấp Hardy, và ψ là hàm sụp đổ thứ tự dưới Bachmann-Howard thứ tự xác định bởi Pohlers.

Cảm ơn Jonathan Frech cho -3 byte.

def S (T): trả về 0if T == 1else [S (T [0])] + T [1:]
def R (T): U = T [0]; V = T [1:]; exec "toàn cầu B; B = T" * (T [-1] == 0); return [S (B)] + V nếu U == 1else [R (U)] * c + V nếu U khác V
A = [[[1,1], 1], 0]
c = 9
trong khi A: A = R (A); c * = c
in c

Hãy thử trực tuyến!

Phiên bản khoảng cách tốt hơn:

def S (T):
  trả về 0 nếu T == 1 khác [S (T [0])] + T [1:]

def R (T):
  U = T [0]
  V = T [1:]
  toàn cầu B
  nếu T [-1] == 0:
    B = T
  nếu U == 1: 
    trả về [S (B)] + V
  trả về [R (U)] * c + V nếu U khác V

A = [[[1,1], 1], 0]
c = 9
trong khi một:
  A = R (A)
  c * = c
in c

Giải trình:

Chương trình này thực hiện một biến thể của Congholz hydra , chỉ sử dụng nhãn 0 và 1. Về cơ bản, ở mỗi bước, chúng ta nhìn vào nút lá đầu tiên của cây và xem nó có được dán nhãn 0 hoặc 1 không.

-Nếu nút lá được gắn nhãn 0, sau đó chúng tôi xóa nút lá và sau đó sao chép cây bắt đầu từ cha mẹ của nút lá c lần, tất cả các bản sao được kết nối với ông bà của nút lá.

-Nếu nút lá được gắn nhãn 1, thì chúng ta sẽ tìm kiếm trở lại gốc cho đến khi chúng ta đến được nút tổ tiên có nhãn 0. Gọi S là cây bắt đầu từ nút tổ tiên đó. Đặt S 'là S với nút lá được định vị lại bằng 0. Thay thế nút lá bằng S'.

Sau đó chúng tôi lặp lại quá trình cho đến khi chúng tôi không còn gì ngoài nút gốc.

Chương trình này khác với quy trình hydra của Hội trưởng thông thường theo hai cách: Thứ nhất, sau khi chúng tôi thực hiện quy trình trên, chúng tôi lấy lại cây và thực hiện quy trình sao chép nhãn 0 được mô tả ở trên cho mỗi nút tổ tiên của nút lá ban đầu. Điều này làm tăng kích thước của cây, vì vậy quy trình của chúng tôi sẽ mất nhiều thời gian hơn so với hydhol Buchholz bình thường, và do đó dẫn đến một số lượng lớn hơn cuối cùng; tuy nhiên, nó vẫn sẽ chấm dứt bởi vì thứ tự liên quan đến cây mới vẫn sẽ ít hơn cây cũ. Sự khác biệt khác là, thay vì bắt đầu với c = 1 và tăng 1 mỗi lần, chúng ta bắt đầu với c = 9 và bình phương mỗi lần, bởi vì tại sao không.

Cây [[[1,1], 1], 0] tương ứng với ψ thứ tự (Ohm ^{Ohm Ohm} ), mà là lớn hơn đáng kể so với θ thứ tự (Ohm ^w w), và do đó chúng tôi kết quả số cuối cùng của khoảng H _{ψ (Ohm ^{Ohm Ohm} )} (9) chắc chắn sẽ vượt quá TREE (3).

Ruby, 140 byte, ~ H _{(Ω ^{Ω Ω} )} (81)

nơi H là hệ thống phân cấp Hardy , và ψ là thứ tiêu chuẩn chức năng dưới Bachmann-Howard thứ sụp đổ, như đã định nghĩa ở đây .

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

Hãy thử trực tuyến!

Phiên bản bị đánh cắp:

def S (a)
  * v, u = a
  nếu a == 1 
    trở về []
  khác
    trở lại v + [S (u)]
  kết thúc
kết thúc  

def R (t)
  * v, u = t
  nếu t [0] == []
    $ b = t
  kết thúc
  nếu bạn == 1
    trả lại v + [S ($ b)]
  elsif u == []
    trở lại v
  khác
    trả lại v + [R (u)] * $ c
  kết thúc
kết thúc

$ c = 9

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

trong khi a! = [] làm
  $ c * = 9
  a = R (a)
kết thúc

in $ c

Chương trình này thực hiện hydra Buchholz với các nút được gắn nhãn [] và 1, như được mô tả trong mục Python 2 của tôi.

Cây [[], [1, [1,1]]] tương ứng với số thứ tự ψ ( ^{Ω Ω} ), lớn hơn đáng kể so với số thứ tự ϑ (Ω ^ω ω) = ψ (Ω ^{Ω ω ω} ), và do đó, kết quả cuối cùng của chúng tôi về H _{ψ ( ^{Ω Ω} )} (81) sẽ vượt quá TREE (3).

Julia, 569 byte, Số bộ tải

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

Để tiết kiệm cho bản thân một chút công việc, tôi quyết định chuyển Loader.c cho Julia gần như từng người một và thu gọn nó vào khối mã ở trên. Đối với những người muốn tự so sánh (để xác minh việc ghi điểm của tôi hoặc để giúp tôi tìm ra lỗi hoặc cải thiện mã của mình), một phiên bản không được cung cấp dưới đây:

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

Không có số lượng trước đây bởi vì tôi đã thực hiện quá nhiều sai lầm byte trong việc chơi golf tích cực mà tôi đã thực hiện.

JavaScript, 190B, H _{(ε Ω + 1 )} (9) _{Dựa trên phân tích này}

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

Chương trình này là phiên bản sửa đổi của bản dịch số thứ tự cặp 225B này trong JavaScript . Để biết số thứ tự cặp và mã gốc của chúng, xem tại đây .

Các sửa đổi được thực hiện:

• Nó có trong JavaScript thay vì BASIC.
• Không lặp (f _{ψ (Ω W +1)} -> f _{ψ (Ω w )} )
• Trình tự là (0,0) (1,1) (2,2), tương ứng với thứ tự ψ (ε _{Ω + 1} ). _{Đây là thứ tự Hardy-phân cấp}