TREE (k) 함수는 트리 T ₁ , T ₂ 등 의 가장 긴 시퀀스의 길이를 제공합니다 . 여기서 각 정점은 k 색상 중 하나로 레이블이 지정되고 트리 T _i 는 최대 i 정점을 가지며 트리는 없습니다. 사소한 어떤 나무는 순서에 따라.

TREE (1) = 1, 예를 들어 T ₁ = (1).

TREE (2) = 3 : 예 : T ₁ = (1); T ₂ = (2)--(2); T ₃ = (2).

TREE (3)는 큰 숫자입니다. 그레이엄의 수보다 훨씬 큽니다. 당신의 직업은 그것보다 더 큰 숫자를 출력하는 것입니다!

이것은 코드 골프 이므로 목표는 TREE (3)보다 크거나 같은 숫자를 stdout에 결정적으로 출력하는 언어로 가장 짧은 프로그램을 작성하는 것입니다.

• 입력 할 수 없습니다.
• 프로그램은 결국 종료해야하지만 시스템에 무한 메모리가 있다고 가정 할 수 있습니다.
• 언어의 숫자 유형이 유한 값을 가질 수 있다고 가정 하지만 언어에서 이것이 정확히 어떻게 작동하는지 설명해야합니다 (예 : 부동 소수점의 정밀도는 정확합니까?)
  • 무한대는 출력으로 허용되지 않습니다.
  • 숫자 유형의 언더 플로에서 예외가 발생합니다. 감싸지 않습니다.
• TREE (3)은 복잡한 숫자이므로 빠르게 성장하는 계층 근사 f f _{(Ω ^ω ω) +1} (3)을 이길 숫자로 사용할 수 있습니다.
• 솔루션이 유효한지 확인하기 위해 숫자가 너무 큰 이유와 코드의 코드 버전이없는 이유에 대한 설명을 제공해야합니다 ( TREE (3) 을 저장할 메모리가 충분한 컴퓨터가 없기 때문에 )

참고 : 현재 여기 에있는 답변 중 아무것도 작동하지 않습니다.

TREE (3)가 왜 그렇게 큰가요?

새로운 루비, 135 바이트, >> H _{ψ (φ 3 (Ω + 1))} (9)

여기서 H 는 하디 계층이며, ψ 는 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 : (람다가 아닌 함수 사용)

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], Bachmann-Howard 서수 ψ (Ω ^{Ω Ω ...} )보다 큽니다. 이는 ϑ (Ω ^ω ω) +1 보다 큽니다 .

ψ (Ω (↓ 9) 9)> ψ (Ω (↓ 4) 3)> ψ (Ω ^{Ω Ω} ) +1> ψ (Ω ^{Ω ω ω} ) +1> ϑ (Ω ^ω ω) +1

그리고 만약 나의 분석이 정확하다면, ψ '(Ω ^Ω ∙ x) ~ = ψ * (Ω ^Ω ∙ x)를 가져야합니다 . 여기서 ψ *는 마 도르의 정상적인 psi 함수입니다. 이것이 유지되면 내 서수는 대략 ψ * (φ ₃ (Ω + ω))입니다.

오래된 루비, 309 바이트, H _{ψ ' 0 (Ω 9 )} (9) ( 새로운 것 외에 개정 이력 참조 )

하스켈, 252 바이트, 트리 (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 및 Ørjan Johansen의 도움에 감사드립니다!

HyperNeutrino 에서 제안한대로 내 프로그램은 TREE (3) +1을 정확하게 출력합니다 (TREE는 계산 가능하므로 계산 가능합니다).

T n c레이블 c과 노드 가있는 트리입니다 n. c해야한다 1, 2또는 3.

l t트리의 노드 수입니다 t.

t1 # t2(유형 4.4에 근거한) t1동종 형에 삽입하는 경우 true이고 , 그렇지 않으면 false입니다.t2

a n큰 나무 목록을 출력합니다. 정확한 목록은 중요하지 않습니다. 중요한 속성 즉 a n에 모든 나무를 포함 n노드로 표시되면서, 노드 1, 2또는 3, 어쩌면 좀 더 나무뿐만 아니라 (그러나 그 다른 나무도 함께 표시됩니다 1, 2또는 3). 유한 목록을 출력하는 것도 보장됩니다.

s nn트리의 모든 시퀀스 길이 를 나열하여 해당 시퀀스 의 역순으로 구성합니다. n 번째 요소 (1부터 계산을 시작하는 위치)에 최대 n 개의 노드가 있고 후자에 트리가 동종 형성으로 임베드되지 않으면 시퀀스가 ​​유효합니다.

mainn유효한 길이의 시퀀스가 ​​없도록 최소값을 인쇄합니다 n.

이후 TREE(3)긴 유효 시퀀스의 길이로 정의되는, TREE(3)+1가장 작은 n길이의 유효한 시퀀스 없는지 등 n어떤 내 프로그램 출력이다.

파이썬 2, 194 바이트, ~ H _{ψ (Ω ^{Ω Ω} )} (9)

여기서 H 는 하디 계층이며, ψ 는 Pohlers가 정의한 Bachmann-Howard 서수 아래의 서수 축소 함수입니다.

-3 바이트의 Jonathan Frech에게 감사합니다.

데프 S (T) : T == 1이면 0을 반환 [S (T [0])] + T [1 :]
데프 R (T) : U = T [0]; V = T [1 :]; exec "global B; B = T"* (T [-1] == 0); 반환 [S (B)] + U == 1 인 경우 V V; 그렇지 않으면 V 인 경우 R [U (U)] * c + 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 이외의 경우 V [R (U)] * c + V를 반환

A = [[[1,1], 1], 0]
c = 9
A 동안 :
  A = R (A)
  c * = c
인쇄 c

설명:

이 프로그램 은 0과 1의 레이블 만 사용하여 Buchholz hydra 의 변형을 구현합니다 . 기본적으로 각 단계에서 트리의 첫 번째 리프 노드를보고 0 또는 1로 레이블이 지정되어 있는지 확인합니다.

-리프 노드에 0으로 레이블이 지정된 경우 리프 노드를 삭제 한 다음 리프 노드의 부모에서 시작하여 트리를 복사합니다. 모든 복사본은 리프 노드의 조부모에 연결됩니다.

-리프 노드에 1로 레이블이 지정되어 있으면 0으로 레이블이 지정된 조상 노드에 도달 할 때까지 루트쪽으로 다시 검색합니다. S가 해당 상위 노드에서 시작하는 트리가되도록합니다. 리프 노드가 0으로 레이블이 지정된 S '를 S로 둡니다. 리프 노드를 S'로 바꿉니다.

그런 다음 루트 노드 만 남을 때까지 프로세스를 반복합니다.

이 프로그램은 두 가지면에서 일반적인 Buchholz hydra 절차와 다릅니다. 먼저, 위의 절차를 수행 한 후 트리를 다시 백업하고 원래 리프 노드의 각 조상 노드에 대해 위에서 설명한 레이블 0 복사 절차를 수행합니다. 이것은 나무의 크기를 증가 시키므로 우리의 절차는 정상적인 Buchholz hydra보다 시간이 오래 걸리므로 결국에는 더 큰 숫자로 이어집니다. 그러나 새 트리와 관련된 서 수가 여전히 오래된 트리보다 작기 때문에 여전히 종료됩니다. 또 다른 차이점은 c = 1로 시작하고 매번 1 씩 증가시키는 것이 아니라 c = 9로 시작하여 매번 제곱하는 것입니다.

트리 [[[1,1], 1, 0] 서수 ψ (Ω에 대응 ^{Ω Ω} 서수 θ보다 훨씬 크다), (Ω ^ω 우리는 H에 대한 최종 수의 결과 ω) 및 있도록 _{ψ를 (Ω ^{Ω Ω} )} (9)는 TREE (3)를 확실히 초과합니다.

루비, 140 바이트, ~ H _{ψ (Ω ^{Ω Ω} )} (81)

여기서 H 는 하디 계층 이며, ψ 는 여기에 정의 된 바흐 만 하워드 서수 아래의 표준 서수 축소 함수 입니다.

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

반면에! = [] do
  $ c * = 9
  a = R (a)
종료

인쇄 $ c

이 프로그램은 Python 2 항목에 설명 된대로 [] 및 1로 레이블이 지정된 노드로 Buchholz hydra를 구현합니다.

트리 [[], [1, [1,1]]]은 서수 ψ (Ω ^{Ω Ω} )에 해당하며 서수 ϑ (Ω ^ω ω) = ψ (Ω ^{Ω ω ω} ) 보다 상당히 큽니다. 따라서 H _{Hψ (Ω ^{Ω Ω} )} (81) 의 최종 결과 수는 TREE (3)를 초과합니다.

Julia, 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 Pair-sequence number translation 의 수정 된 버전입니다 . 페어 시퀀스 번호 및 원래 코드는 여기를 참조 하십시오 .

수정 완료 :

• BASIC 대신 JavaScript로되어 있습니다.
• 반복 없음 (f _{ψ (Ω ω +1)} -> f _{ψ (Ω ω )} )
• 순서는 (0,0) (1,1) (2,2)이며 이는 서수 ψ (ε _{Ω + 1} )에 해당합니다. _{이것은 하디 계층 서수에 있습니다}