다음 요구 사항을 충족하는 가장 짧은 가능한 프로그램 (바이트 단위로 측정 된 길이)을 작성하십시오.

• 입력이 없습니다
• 출력은 표준 출력입니다
• 실행이 결국 종료됩니다
• 총 출력 바이트 수가 Graham의 수를 초과 함

무제한 자원에 액세스 할 수 있는 이상적인 컴퓨터 ¹ 에서 프로그램이 "정상"종료 될 때까지 프로그램이 실행 되고 필요한 경우 구문을 변경하지 않고 공통 프로그래밍 언어가 수정되었다고 가정합니다. 이러한 가정 때문에 우리는 이것을 일종의 게단 켄 실험이라고 할 수 있습니다.

작업을 시작하기 위해 빠르게 성장하는 계층 구조 에서 f _{ω + 1} (99) 를 계산하는 73 바이트 Ruby 프로그램이 있습니다 .

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, 함수를 취하여 행에 3 번 적용하는 것과 같은 f함수를 반환합니다 . 이 고차 함수의 적용을 반복하면 지수 증가로 시작하여 빠르게 증가하는 함수 시퀀스가 ​​나타 납니다. 는 Graham의 수에 대한 계산에 나타나는 것입니다. 해야 할 일은 함수를 작성하는 것입니다.nfn-1
((%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 33 ↑ⁿ 3(\n -> 3 ↑ⁿ 3) ≡ flip((%3)%(3^))3Graham의 수보다 큰 수를 얻으려면 4 (계산으로 시작하는 화살표 수) 위에 64 회 이상. 의 로그 (임의로 느린 함수입니다!) g₆₅가 여전히보다 큽니다 . 따라서이 g₆₄=G숫자를 인쇄하면 출력 길이가을 (를) 초과 G합니다.

⬛

Pyth , 29 28 바이트

M?*GHgtGtgGtH^ThH=ZTV99=gZTZ

하이퍼 오퍼레이션을위한 람다를 정의하고 재귀 적으로 호출합니다. Graham의 수에 대한 정의와 같지만 더 큰 값을 갖습니다.

이:

M?*GHgtGtgGtH^3hH

파이썬과 거의 같은 람다를 정의합니다

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

재귀 적으로 Graham 's Number를 제공하는 하이퍼 오퍼레이션을 64 번 이상 호출해야합니다.

그러나 내 대답에서 단일 숫자 T를 10으로 초기화하고 재귀 깊이를 99로 늘 렸습니다. Graham Array Notation을 사용하면 Graham 's Number는 [3,3,4,64]이고 프로그램은 더 큰 [10,11,11,99]를 출력합니다. 또한 )루프를 닫아 1 바이트를 저장 하는 것을 제거 했으므로 99 개의 반복으로 각 연속 값을 인쇄합니다.

파이썬 (111 + n), n = 길이 (x)

이것은 응답자의 루비 프로그램만큼 짧지는 않지만 어쨌든이 가능성을 배제하기 위해 게시 할 것입니다.

Ackermann 함수를 사용하고 다른 호출에서 Ackermann 함수에 대한 값인 m과 n을 사용하여 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))

루비, 54 52 50 바이트

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

루비, 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)로 상당히 빠르게 성장하는 계층 구조 .

루비, 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 기능.

루비, 63 59 바이트

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

또 다른 루비, 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 번 자체 기능을합니다.

파이썬 : 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일부 바이트가 저장됩니다).

참고 : 파이썬 코드가 대화 형 인터프리터에서 실행되므로 결과가 표준 출력으로 인쇄되고 그렇지 않으면 9에 대한 호출을 위해 각 솔루션에 바이트를 추가 합니다 print.

자바 스크립트, 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 )입니다.