TREE (k) 함수는 트리 T 1 , T 2 등 의 가장 긴 시퀀스의 길이를 제공합니다 . 여기서 각 정점은 k 색상 중 하나로 레이블이 지정되고 트리 T i 는 최대 i 정점을 가지며 트리는 없습니다. 사소한 어떤 나무는 순서에 따라.
TREE (1) = 1, 예를 들어 T 1 = (1)
.
TREE (2) = 3 : 예 : T 1 = (1)
; T 2 = (2)--(2)
; T 3 = (2)
.
TREE (3)는 큰 숫자입니다. 그레이엄의 수보다 훨씬 큽니다. 당신의 직업은 그것보다 더 큰 숫자를 출력하는 것입니다!
이것은 코드 골프 이므로 목표는 TREE (3)보다 크거나 같은 숫자를 stdout에 결정적으로 출력하는 언어로 가장 짧은 프로그램을 작성하는 것입니다.
- 입력 할 수 없습니다.
- 프로그램은 결국 종료해야하지만 시스템에 무한 메모리가 있다고 가정 할 수 있습니다.
- 언어의 숫자 유형이 유한 값을 가질 수 있다고 가정 하지만 언어에서 이것이 정확히 어떻게 작동하는지 설명해야합니다 (예 : 부동 소수점의 정밀도는 정확합니까?)
- 무한대는 출력으로 허용되지 않습니다.
- 숫자 유형의 언더 플로에서 예외가 발생합니다. 감싸지 않습니다.
- TREE (3)은 복잡한 숫자이므로 빠르게 성장하는 계층 근사 f f (Ω ω ω) +1 (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 함수입니다. 이것이 유지되면 내 서수는 대략 ψ * (φ 3 (Ω + ω))입니다.
오래된 루비, 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 n
n
트리의 모든 시퀀스 길이 를 나열하여 해당 시퀀스 의 역순으로 구성합니다. n 번째 요소 (1부터 계산을 시작하는 위치)에 최대 n 개의 노드가 있고 후자에 트리가 동종 형성으로 임베드되지 않으면 시퀀스가 유효합니다.
main
n
유효한 길이의 시퀀스가 없도록 최소값을 인쇄합니다 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 )에 해당합니다. 이것은 하디 계층 서수에 있습니다