BigNum 베이크 오프 재부팅


12

여러분 중 일부는 BigNum Bakeoff에 익숙 할 것 입니다. 목표는 다소 제약 조건과 이론적 조건, 예를 들어 프로그램을 실행할 수있는 컴퓨터에서 출력이 가장 큰 C 프로그램을 작성하는 것으로 요약 될 수 있습니다.

같은 정신으로, 나는 모든 언어에 열려있는 비슷한 도전을하고 있습니다. 조건은 다음과 같습니다.

  • 최대 512 바이트 .

  • 최종 결과는 STDOUT에 인쇄해야합니다. 이것은 당신의 점수입니다. 여러 정수가 인쇄되면 연결됩니다.

  • 출력은 정수 여야합니다. (참고 : 무한대는 정수가 아닙니다 .)

  • 10보다 큰 내장 상수는 없지만 숫자 / 숫자는 괜찮습니다 (예 : Avogadro의 상수 (내장 상수)는 유효하지 않지만 10000은 아닙니다).

  • 실행하기에 충분한 자원이 제공되면 프로그램 을 종료해야합니다 .

  • 실행하기에 충분한 리소스가 제공되면 인쇄 된 출력물이 결정적 이어야합니다 .

  • 프로그램을 실행하기에 충분한 정수 또는 bigint가 제공됩니다. 예를 들어, 프로그램에서 10 1,000,000 보다 작은 숫자에 기본 연산을 적용해야하는 경우,이를 실행하는 컴퓨터가 최소 10 1,000,000 까지의 숫자를 처리 할 수 ​​있다고 가정 할 수 있습니다 . (참고 : 최대 10 2,000,000 까지의 숫자를 처리하는 컴퓨터에서 프로그램을 실행할 수도 있으므로 컴퓨터가 처리 할 수있는 최대 정수를 호출해도 결정적인 결과가 나오지 않습니다.)

  • 5 초 이내에 프로그램 실행을 완료 할 수있는 충분한 컴퓨팅 성능이 제공됩니다. (따라서 프로그램이 컴퓨터에서 한 시간 동안 실행되어 곧 종료되지 않을까 걱정하지 마십시오.)

  • 외부 리소스가 없으므로 내장 기능이 아닌 경우 Ackermann 함수를 가져 오는 것에 대해 생각하지 마십시오.

모든 마법 아이템은 관대 한 신에게서 일시적으로 빌려오고 있습니다.

알 수없는 한계를 가진 매우 큰

여기서 B³F는 기본 순서가있는 교회-클린 서수입니다.

B³F[n] = B³F(n), the Busy Beaver BrainF*** variant
B³F[x] = x, ω ≤ x < B³F

리더 보드 :

  1. 단순히 아름다운 예술 , 루비 f ψ 0 (X (Ω M + X (Ω M + 1 Ω M + 1 ) )) + 29 (9 9 9 )

  2. Steven H , Pyth f ψ (Ω Ω ) + ω² + 183 (256 27! )

  3. 새는 수녀 , Python 3 f ε 0 (9 9 9 )

  4. fejfo , Python 3 f ω ω 6 (f ω ω 5 (9e999))

  5. 스티븐 H , 파이썬 3 f ω ω + ω² (9 9 9 99 )

  6. 단순히 아름다운 예술 , 루비 f ω + 35 (9 9 99 )

  7. i .. , Python 2 , f 3 (f 3 (141))

몇 가지 참고 사항 :

점수를 확인할 수 없으면 순위표에 올릴 수 없습니다. 따라서 프로그램을 약간 설명하는 것이 좋습니다.

마찬가지로, 당신이 당신의 숫자가 얼마나 큰지 이해하지 못하는 경우, 프로그램을 설명하고 우리는 그것을 해결하려고 노력할 것입니다.

Loader의 숫자 유형 프로그램 을 사용하는 경우 Loader의 숫자에 '빠르게 증가하는 계층 구조 측면에서 사소한 상한선이 없으므로 '알 수없는 한계를 가진 매우 큰 ' 이라는 별도의 범주에 배치합니다. 표준의 기본 순서.

숫자는 빠르게 성장하는 계층 구조 를 통해 순위가 결정됩니다 .

빠르게 성장하는 계층 구조를 사용하여 실제로 많은 수를 추정하는 방법을 배우려는 사람들을 위해 Discord 서버를 호스팅하고 있습니다. 대화방도 있습니다 : Ordinality .

비슷한 과제 :

인쇄 가능한 최대 개수

TREE (3)보다 큰 수의 골프

출력 크기가 Graham의 수를 초과하는 최단 종료 프로그램

작은 값에 대해 빠르게 성장하는 계층 구조를 출력하는 간단한 프로그램을 보려면 다음과 같습니다.

루비 : 빠르게 성장하는 계층

#f_0:
f=->n{n+=1}

#f_1:
f=->n{n.times{n+=1};n}

#f_2:
f=->n{n.times{n.times{n+=1}};n}

#f_3:
f=->n{n.times{n.times{n.times{n+=1}}};n}

#f_ω:
f=->n{eval("n.times{"*n+"n+=1"+"}"*n);n}

#f_(ω+1):
f=->n{n.times{eval("n.times{"*n+"n+=1"+"}"*n)};n}

#f_(ω+2):
f=->n{n.times{n.times{eval("n.times{"*n+"n+=1"+"}"*n)}};n}

#f_(ω+3):
f=->n{n.times{n.times{n.times{eval("n.times{"*n+"n+=1"+"}"*n)}}};n}

#f_(ω∙2) = f_(ω+ω):
f=->n{eval("n.times{"*n+"eval(\"n.times{\"*n+\"n+=1\"+\"}\"*n)"+"}"*n);n}

기타

에서 f_x로 이동하기 위해의 f_(x+1)루프 하나를 추가합니다 n.times{...}.

그렇지 않으면, 우리는 이전의 모든 예와 대각선을 이룹니다

f_ω(1) = f_1(1)
f_ω(2) = f_2(2)
f_ω(3) = f_3(3)

f_(ω+ω)(1) = f_(ω+1)(1)
f_(ω+ω)(2) = f_(ω+2)(2)
f_(ω+ω)(3) = f_(ω+3)(3)

기타


숫자는 내장 상수로 계산됩니까?
PyRulez

3
@CloseVoters 어떻게 이것이 너무 넓을 수 있을까요 ... 글쎄, 사용자에게 하나의 숫자를 무한히 많은 숫자로 출력하도록 요구하는 것은 사용자가 무한히 많은 작업 중 하나를 선택하도록 요구하는 것과 다릅니다. 이 질문을 공정하게하려면 사용자에게 동일한 작업을 수행하도록 요청하십시오. 너무 광범위 이미 같은 4 명 가까운 투표 ...
user202729

1
@ 그렇습니다. 그러나 더 빠른 계산을 포함하여 프로그램에 더 많은 리소스가 제공 될 때 출력은 여전히 ​​결정적이어야합니다.
Simply Beautiful Art

1
나는 다른 의견 섹션에서 제한된 Brainfuck Busy Beaver 기능이 지수 적이라고 생각하는 이유를 언급했지만 더 일반적으로 교회-Kleene 서 수가 모든 컴퓨터 프로그램에 적합한 수준이라고 생각하지 않습니다. . 프로그램으로 코딩 할 수있는 함수는 계산 가능하므로 충분히 강한 재귀 사운드 이론의 재귀 함수에 속해야합니다. 그 이론은 재귀 적 증거 이론적 서수를 가질 것이며, 그 함수는 합리적인 기본 순서를 가정 할 때 FGH에서 그 서수보다 낮을 것입니다.
Deedlit

1
물론 실제 Busy Beaver 기능은 프로그램으로 코딩 될 수 없으며 (과 계산 된 언어는 제외) 필요에 따라 프로그래밍 할 수있는 제한된 Busy Beaver 기능은 훨씬 느리게 성장해야합니다.
Deedlit

답변:


7

루비, f ψ 0 (X (Ω M + X (Ω M + 1 Ω M + 1 ) )) + 29 (9 9 9 )

여기서 M 은 첫 번째 Mahlo 'ordinal'이고 X 는 카이 함수 (Mahlo collapsing function)이며 ψ 는 서수 접기 함수입니다.

f=->a,n,b=a,q=n{c,d,e=a;!c ?[q]:a==c ?a-1:e==0||e&&d==0?c:e ?[[c,d,f[e,n,b,q]],f[d,n,b,q],c]:n<1?9:!d ?[f[b,n-1],c]:c==0?n:[t=[f[c,n],d],n,c==-1?[]:d==0?n:[f[d,n,b,t]]]};(x=9**9**9).times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{h=[];x.times{h=[h,h,h]};h=[[-1,1,[h]]];h=f[h,p x*=x]until h!=0}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}

온라인으로 사용해보십시오!

코드 분석 :

f=->a,n,b=a,q=n{          # Declare function
                c,d,e=a;          # If a is an integer, c=a and d,e=nil. If a is an array, a=[c,d,e].compact, and c,d,e will become nil if there aren't enough elements in a (e.g. a=[1] #=> c=1,d=e=nil).
                        !c ?[q]:          # If c is nil, return [q], else
                                a==c ?a-1:          # If a==c, return a-1, else
                                          e==0||e&&d==0?c:          # If e==0 or e is not nil and d==0, return c, else
                                                          e ?[[c,d,f[e,n,b,q]],f[d,n,b,q],c]:          # If e is not nil, return an array inside an array, else
                                                                                             n<1?9:          # If n<1, return 9, else
                                                                                                   !d ?[f[b,n-1],c]:          # If d is nil, return [f[b,n-1],c], else
                                                                                                                    c==0?n:          # If c==0, return n, else
                                                                                                                           [t=[f[c,n],d],n,c==-1?[]:d==0?n:[f[d,n,b,t]]]          # t=[f[c,n],d]. If c==-1, return [t,n,[]], else if d==0, return [t,n,n], else return [t,n,[f[d,n,b,t]]].
                                                                                                                                                                        };          # End of function
                                                                                                                                                                          (x=9**9**9)          # Declare x
                                                                                                                                                                                     x.times{...}          # Looped within 33 x.times{...} loops
                                                                                                                                                                                                 h=[];          # Declare h
                                                                                                                                                                                                      x.times{h=[h,h,h]};          # Nest h=[h,h,h] x times
                                                                                                                                                                                                                         h=f[h,p x*=x]          # Apply x*=x, print x, then h=f[h,x]
                                                                                                                                                                                                                                      until h==0          # Repeat previous line until h==0

수학 분석 :

f에 따라 줄 a입니다 n,b,q.

기본 아이디어는 매우 중첩되어 a있고로 축소 될 때까지 반복적으로 줄이는 것 a=0입니다. 간단하게하기 위해

g[0,n]=n
g[a,n]=g[f[a,n],n+1]

지금은 걱정하지 마십시오 n.

모든 정수 k에 대해을 얻으 f[k,n]=k-1므로

g[k,n]=n+k

우리는 그 다음 어떤 위해 가지고 d, f[[0,d],n]=n그래서 우리는 것을 알 수 있습니다

g[[0,d],n]
= g[f[[0,d],n],n+1]
= g[n,n+1]
= n+n+1

우리는 그 다음 c,d,ef[[c,0,e],n]=f[[c,d,0],n]=c. 예를 들어

g[[[0,d],0,e],n]
= g[f[[[0,d],0,e]],n+1]
= g[[0,d],n+1]
= (n+1)+(n+1)+1
= 2n+3

그런 다음 c,d,e이전 사례에 해당하지 않는 경우가 f[[c,d,e],n]=[[c,d,f[e,n]],f[d,n],e]있습니다. 이곳이 복잡해지기 시작합니다. 몇 가지 예 :

g[[[0,d],1,1],n]
= g[f[[[0,d],1,1],n],n+1]
= g[[[0,d],1,0],0,[0,d]],n+1]
= g[f[[[0,d],1,0],0,[0,d]],n+1],n+2]
= g[[[0,d],1,0],n+2]
= g[f[[[0,d],1,0],n+2],n+3]
= g[[0,d],n+3]
= (n+3)+(n+3)+1
= 2n+7

#=> Generally g[[[0,d],1,k],n] = 2n+4k+3

g[[[0,d],2,1],n]
= g[f[[[0,d],2,1],n],n+1]
= g[[[[0,d],2,0],1,[0,d]],n+1]
= g[f[[[[0,d],2,0],1,[0,d]],n+1],n+2]
= g[[[[[0,d],2,0],1,n+1],0,[[0,d],2,0]]],n+2]
= g[f[[[[[0,d],2,0],1,n+1],0,[[0,d],2,0]]],n+2],n+3]
= g[[[[0,d],2,0],1,n+1],n+3]
= ...
= g[[[0,d],2,0],3n+6]
= g[f[[[0,d],2,0],2n+6],3n+7]
= g[[0,d],3n+7]
= (3n+7)+(3n+7)+1
= 6n+15

거기에서 빨리 올라옵니다. 몇 가지 관심 사항 :

g[[[0,d],3,[0,d]],n] ≈ Ack(n,n), the Ackermann function
g[[[0,d],3,[[0,d],0,0]],63] ≈ Graham's number
g[[[0,d],5,[0,d]],n] ≈ G(2^^n), where 2^^n = n applications of 2^x, and G(x) is the length of the Goodstein sequence starting at x.

결과적으로 f함수 에 대한 더 많은 인수와 배열에 대한 더 많은 사례를 도입하면 대부분의 명명 된 계산 표기법을 능가 할 수 있습니다. 특별히 알려진 것들 :

g[[[0],3,[0,d]],n] ≈ tree(n), the weak tree function
g[[[[0],3,[0,d]],2,[0,d]],n] ≈ TREE(n), the more well-known TREE function
g[[[[0,d]],5,[0,d]],n] >≈ SCG(n), sub-cubic graph numbers
g[[[0]],n] ≈ S(n), Chris Bird's S function

1
서수 설명?
CalculatorFeline

이것이 가장 큰 정의 번호입니까? 그렇게 나타납니다!
ThePlasmaRailgun

3

Pyth, f ψ (Ω Ω ) + ω 2 +183 (~ 256 27! )

=QC`.pGL&=^QQ?+Ibt]0?htb?eb[Xb2yeby@b1hb)hbXb2yeb@,tb&bQ<b1=Y_1VQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQ.v%%Fms["*s[.v"*\\^2d"\"%s"*\\^2d"\"")Qs["=Y.v+*"*\\^2Q"\"*3]"*\\^2Q"\"Q\YuyFYHpQ)

비어 있지 않은 입력이 필요하지만 그 값은 사용되지 않습니다.

설명 ( 새롭고 합리적으로 점수가 매겨진 버전의 경우) :

=QC`.pG                   Sets the value of the autofill variable to app. 256^27!  
                                  27! ~= the number of characters in the string
                                  containing all permutations of the alphabet. 
                                  We interpret that string as a base-256 number.
       L                  Define a function y(b,global Q):
        &=^QQ             Set Q to Q^Q and:
        ?+Ibt]0           If (?) the variable (b) is (I)nvariant on (+)adding itself
                             to the empty array (i.e. if it's an array itself):
               ?htb        If the second element of b is not 0:
                   ?eb         If the last element is not 0
                       [Xb2yeby@b1hG)   return [b with its last element replaced with y(b[-1]), y(b[1]), b[0]]
                     hb                 else return b[0]
                 Xb2yeb     else return b with its last element replaced with y(b[-1])
           @,tb&bQ<b1      If b isn't an array,return:
                               either b-1 if it's a standard ordinal (1 or more)
                               or Q if b is ω
                               or 0 if b is 0
 =Y_1                          Set the global variable Y to -1 (representing ω)
 VQ                        Q times, do (the rest of the explanation):
  VQVQ....VQ               Iterate from 0 to Q-1 183 times, each subiteration
                              reading the most recent value of Q when it starts:
  .v%%Fms["*s[.v"*\\^2d"\"%s"*\\^2d"\"")Q
                            Iterate from 0 to Q-1 Q times, each subiteration 
                               reading the most recent value of Q when it starts:                        
 s["=Y.v+*"*\\^2Q"\"*3]"*\\^2Q"\"Q
                             Y = [Y,Y,Y] Q times, stacking with previous iterations.
 uyFYHpQ)                    Run y_x(Y) for x incrementing until y_(x-1)(Y)=0

이 크기를 계산하는 것은 매우 어렵습니다. 주로 늦은 시간이며 빠르게 성장하는 계층 구조에 익숙하지 않거나 Q가 통과하는 횟수를 파악하려고 시도하는 방법에 대해 잘 알고 있지 않습니다. y()기수. 이제 서수에 대해 더 많이 알고 있지만 여전히 프로그램의 재귀 정의로 표시되는 서수 값을 계산하는 방법을 모릅니다. Discord 서버에 가입했지만 가명 아래 내 실제 이름과 연결되어 있지 않습니다.

불행히도, 나는 빠르게 성장하는 계층에 대해 상대적으로 거의 알지 못하기 때문에 이미 Ruby의 대답을 잃어 버렸을 것입니다. 말하기가 어렵습니다. 루비 답변을 이겼을 수도 있지만 100 % 확신 할 수는 없습니다. ¯ \ _ (ツ) _ / ¯


내가 올바르게 이해한다면 귀하의 점수는 아마도 27^^^27^^27^^4, 또는 의 야구장 어딘가에있을 것입니다 f<sub>4</sub>(27^^27^^4)) ≈ f<sub>4</sub>(f<sub>3</sub>(f<sub>3</sub>(19))).
Simply Beautiful Art

나는 어제 생각해야 할 작은 변화를 y겪었 지만 어쨌든 작동하는 y(Q-1)대신 작동하도록 재귀를 하지 않았습니다 Q. 이것이 점수에 어떤 영향을 줍니까?
Steven H.

1
무슨 일인지 잘 모르겠습니다. 합니까 y(Q) = L(y(Q-1)), 그 자체?
Simply Beautiful Art

1
나는 우리가 대화방 에서 이것을하는 것이 더 좋을 것이라고 생각 합니다.
Steven H.

@SimplyBeautifulArt 작은 종류이기 때문에 빠르게 성장하는 계층 표기법을 사용하지 않는 것이 가장 좋습니다.
PyRulez 1

3

피스, f 3 + σ -1 + ω 2 (256 26 )

여기서 σ m [n]은 m호출 된 순서의 Busy Beaver 기능 Σ입니다 n. σ m [n] = Σ m (n). 순서 -1는 여기서 Busy Beaver가 진정한 Turing Machine에서 호출되는 것이 아니라 유한 Q요소의 랩핑 테이프를 사용한 근사치임을 나타냅니다 . 이를 통해 이러한 프로그램에 대해 정지 문제를 해결할 수 있습니다.

=QCGM.x-Hlhf!-/T4/T5.__<GH0M.x+Hlhf!-/T4/T5._>GHlGL=.<QC`m.uX@[XN2%h@N2l@N1XN2%t@N2l@N1XN1X@N1@N2%h@@N1@N2l@N1XN1X@N1@N2%t@@N1@N2l@N1XW!@@N1@N2N2nFKtPNXW@@N1@N2N2gFK)@hNeN3%heNlhNd)bLym*F[]d^UQQUQUld)^U6QJ"s*].v*\mQ"
.v+PPPP*JQ"+*\mQ\'

TL; DR은 이것이 길이 Q의 가능한 모든 BrainF ** k 프로그램을 작성하고, 정수의 최대 값이 Q이고 테이프 길이가 Q 인 환경에서 실행하며, 이들 조작의 모든 상태를 다음과 같이 컴파일합니다. 3+를 f ω 2 의 스케일로 반복하여 Q에 덧붙 입니다.

더 많은 것을 원한다면 작업 할 수있는 ~ 절반의 문자가 있지만, 이것이 어디에 있는지 알아낼 때까지 그대로 두십시오.


리더 보드에서 σ에 대해 좀 더 나은 설명을했습니다.
Simply Beautiful Art

4
이 특정 Busy Beaver 기능이 빠르게 성장하는 것처럼 보이지 않습니다. 0과 Q 사이의 Q 정수 제한으로 프로그램에 (Q + 1) ^ Q 개의 가능한 테이프와 Q 개의 가능한 위치 만 있으므로 최대 Q * (Q + 1) ^ Q의 가능한 상태가있을 수 있습니다. 실행중인 프로그램. 따라서 프로그램은 Q * (Q + 1) ^ Q 단계 내에서 중단되어야합니다. 가능한 프로그램의 수는 지수 상한에 의해 제한됩니다. 이 Busy Beaver 함수에는 지수 상한이 있고, 최종 함수는 $ f _ {\ omega ^ 2} $ 정도 인 것 같습니다.
Deedlit

2

파이썬, f 3 (f 3 (141)), 512 바이트

import math
def f(x):
    return math.factorial(x)  
x=9
for j in range(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(x))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))):
    x=f(x)
print x

이것은 실제로 올바른 대답은 아니지만 어쨌든 게시하고 싶었습니다. 빠른 요약 :

import math # imports the factorial function
def f(x):
    return math.factorial(x) # shortens the factorial operation
x=9 # sets x to highest available number
for j in range(f(...f(x)...)): # repeats * A LOT *
    x=f(x) # does the factorial of x
print x # outputs the result

어쨌든,이 답변이 기술적으로 합법적인지 모르겠지만 작성하는 것이 재미있었습니다. 코드에서 찾은 오류를 자유롭게 편집하십시오.


나는 이것이 f_3 (9)라고 생각하며 확실히 합법적입니다. for j in range(f(x)): for j in range(f(x)): x = f(x)그래도 짝수를 사용하면 훨씬 더 큰 숫자를 얻을 수 있습니다. 이유를 논의하기 위해 채팅 에 참여하십시오 !
Steven H.

왜 정답이 아닌가?
Simply Beautiful Art

나는 질문을 얻지 못했기 때문에 방금 생각한 것을 올바르게 만들었습니다.
i ..

1

루비, 아마도 ~ f ω + 35 (9 9 99 )

G=->n,k{n<1?k:(f=->b,c,d{x=[]
c<G[b,d]?b-=1:(x<<=b;c-=G[b,d])while c>=d
x<<[c]}
x=f[n-1,k,b=1]
(b+=1;*u,v=x;x=v==[0]?u:v==[*v]?u<<[v[0]-1]:u+f[n-1,G[v,b]-1,b])while x[0]
b)};(n=9**9**99).times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n=G[n,n]}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}};p n

온라인으로 사용해보십시오!

대략적인 수학 설명 :

아래는 위의 프로그램과 거의 동일하지만 이해하기 쉽도록 단순화되었습니다.

G(0,k) = k 우리의 기본 기능입니다.

평가 G(n,k)를 위해 다음 k과 같이 작성합니다 G(n-1,1) + ... + G(n-2,1) + ... + G(0,1).

그런 다음 모든 변경 G(x,1)'에들 G(x,2)의'및 빼기 1전체 결과에서.

G(x,2), where을 사용하여 위의 양식으로 다시 작성 x<n하고 나머지는 끝에 둡니다. 반복, 변화 G(x,2)G(x,3)

결과에 도달 언제 -1, 기본 반환합니다 ( b즉에있는 것을 G(x,b).)

예 :

G (1,1) :

1: 1 = G(0,1)
2: G(0,2) - 1 = 1
3: 1 - 1 = 0
4: 0 - 1 = -1      <----- G(1,1) = 4

G (1,2) :

1: 2 = G(0,1) + G(0,1)
2: G(0,2) + G(0,2) - 1 = G(0,2) + 1
3: G(0,3) + 1 - 1 = G(0,3)
4: G(0,4) - 1 = 3
5: 3 - 1 = 2
6: 2 - 1 = 1
7: 1 - 1 = 0
8: 0 - 1 = -1      <----- G(1,2) = 8

G (1,3) :

1: 3 = G(0,1) + G(0,1) + G(0,1)
2: G(0,2) + G(0,2) + G(0,2) - 1 = G(0,2) + G(0,2) + 1
3: G(0,3) + G(0,3)
4: G(0,4) + 3
5: G(0,5) + 2
6: G(0,6) + 1
7: G(0,7)
8: 7
9: 6
10:5
11:4
12:3
13:2
14:1
15:0
16:-1      <----- G(1,3) = 16

G (2,5) :

1: 5 = G(1,1) + G(0,1)
2: G(1,2) + 1
3: G(1,3)
4: G(0,4) + G(0,4) + G(0,4) + G(0,4) + G(0,4) + G(0,4) + G(0,4) + 3
5: G(0,5) + G(0,5) + G(0,5) + G(0,5) + G(0,5) + G(0,5) + G(0,5) + 2
6: G(0,6) + G(0,6) + G(0,6) + G(0,6) + G(0,6) + G(0,6) + G(0,6) + 1
...
1024: -1      <----- G(2,5) = 1024

수학을하면서

G(1,n-1) = 2ⁿ
G(2,n+6) ~ 2^G(2,n),  large enough n.

그리고 그것을 넘어 서면 약간 털이 나오는 경향이 있습니다.

일반적으로

G(n,k+G(n-1,1)) ~ G(n-1,G(n,k)), large enough n.

1

파이썬 3, f ω ω + ω * ω (9 9 9 99 )

from functools import*
h=lambda a,x,b:h(h(a,x,b-1),x-1,a)if x*b else a+b
def f(*x):
    if(any(x[:2]):return reduce(lambda y,z:h(z,y,f(x[0],x[1]-1,*x[2:])),x[::-1])if x[0]*x[1]else(f(x[0]-1,f(x[0]-1,x[0],*x[2:]))if x[0]>x[1]else(f(x[1]-1,f(*([x[1]-1]*2+x[2:])),*x[2:])))
    for a,k in enumerate(x):if k:return f(*[f(*[k]*a,k-1,*x[a+1:])]*a,k-1,*x[a+1:])
    return 0
x,s,g,e,r,z=9**9**9**99,"f(*[%s]*%s)",lambda a,b:a%((b,)*a.count("%")),"x*=eval(\"%s\");","x","x=g(e,g(reduce(g,[s]*x,s),r));"
print(exec(z*x)or eval(r))

곧 설명을 드리겠습니다.


1

파이썬 3 , ~ f ε 0 (9 9 9 )

N=9**9**9
def f(a,n):
 if a[0]==[]:return a[1:]
 if a[0][0]==[]:return[a[0][1:]]*n+a[1:]
 return [f(a[0],n)]+a[1:]
a=eval("["*N+"]"*N)
n=2
while a:a=f(a,n);n+=1
print(n)

온라인으로 사용해보십시오!


은 N = 9 ** 9e99 약간 커야
fejfo

누구의 대답보다?
Leaky Nun

첫 번째를 N = 9 ** 9e99로 바꾸면 9e99> 9 ** 9이기 때문에 출력이 약간 커야합니다. 물론 그것은 여전히 ​​당신의 대답입니다.
fejfo

@fejfo 나는 내 순위를 변경하지 않을 것을 의미합니다.
Leaky Nun

2
그게 중요합니까?
fejfo 2014

1

파이썬 3, 323 바이트, g 9e9 (9)

exec("""a=`x:9**x
n=`a,f:`x:a and n(a-1,f)(f(x))or x
c=`n:`l:l[~n](l)
e=`x:n(x,c(0))([x,`l:[a(l[0]),n(*l)],c(0),`l:[a(l[0]),l[2](l[:2])[1]]+map(`i:l[1]((l[0],i))[1],l[2:])]+list(map(c,range(a(x),1,-1))))[1]
f=`l:[l[1](l[0]),e(l[1](l[0]))(l)[1]]
g=`x:e(x)((x,f))[1]((x,a))[1](x)
print(n(9e9,g)(9))""".replace('`','lambda '))

온라인으로 사용해보십시오!

설명

파이썬 3은 진정한 재귀 언어입니다. 즉, 함수 호출 자체뿐만 아니라 함수는 다른 함수를 입력 또는 출력 함수로 사용할 수도 있습니다. 내 프로그램을 개선하기 위해 함수를 사용하는 것이 내 프로그램의 기반입니다.

f = 람다 x, a : [a (x), e (x) ((x, a)) [1]]

정의

a(x)=9^x
b(x,f)=a(x), f^x
c(n)(*l)=l[~n](l)
c(0)=c0 <=> c0(…,f)=f(…,f)
d(x,b,c,*l)=a(x), c0(x,b), b(x,c0), b(x,f) for f in l
e(x)=c0^x(x,b,c0,d,c(a(x)),c(a(x)-1),c(a(x)-2),…,c(3),c(2),c(1))[1] 
f(x,a)=a(x),e(a(x))(x,a)[1](x)
g(x)=e(x)(x,f)[1](x,a)[1](x)
myNumber=g^9e9(9)

정의 설명

a(x)=9^x a는 기본 함수입니다. 고정 소수점을 피하는 x> 0 => a (x)> x`이기 때문에이 함수를 선택했습니다.

b(x,f)=a(x), f^xb는 일반적인 개선 기능이며, 어떤 기능을 수행하고 더 나은 버전을 출력합니다. b 자체에도 적용 할 수 있습니다.b(x,b)[1]=b^x b(x,b^x)[1]=b^(x*x)

그러나 b개선 의 힘을 완전히 사용하려면 bb의 출력을 가져 와서 새로운 b로 사용해야합니다 .c0은 다음과 같습니다.

c0(…,f)=f(…,f)
c0(x,b^x)=b^x(x,b^x)[1]>b^(9↑↑x)

더 일반적인 C (n)은 함수의 마지막 인자 N (0부터) 정도로 얻어 c(1)(…,f,a)=f(…,f,a)c(2)(…,f,a,b)=f(…,f,a,b). *ll은 배열이고 l[~n]n 개의 마지막 인수를 취함을 의미합니다.

d(x,b,c,*l)=a(x), c0(x,b), b(x,c0), b(x,f) for f in l d는 c0을 사용하여 b를 업그레이드하고 b를 사용하여 다른 모든 입력 기능을 업그레이드합니다 (목록으로 인해 금액이있을 수 있음)
d(x,b,c,d)>9^x,b^x,c^x,d^xd²(x,b,c,d)>a²(x), b^(9↑↑x), c^(9↑↑x), d^(9↑↑x)

그러나 c와 결합하면 d가 더 좋아집니다.
c0²(x,b,c0,d)=d^x(9^x,b^x,c0^x,d^x)=… c0(x,b,c0,d,c1)=c1(x,b,c0,d,c1)=d(x,b,c0,d,c1)=9^x,b^x,c0^x,d^x,c1^x c0²(x,b,c0,d,c1)=c0(9^x,b^x,c0^x,d^x,c1^x)=c1^x(9^x,b^x,c0^x,d^x,c1^x)=…

끝에 c (x)를 더 많이 넣으면 더 강력 해집니다. 첫 번째 c0은 항상 d로 남아 있습니다. c0(x,b,c0,d,c4,c3,c2,c1)=c1(…)=c2(…)=c3(…)=c4(…)=d(x,b,c0,d,cX,cX-1,…,c3,c2,c1)=…
그러나 두 번째 c 는 반복 된 버전을 남겨 둡니다.

c0²(x+1,b,c0,d,c4,c3,c2,c1)
=c0(9^x+1,b^x+1,c0^x+1,d^x+1,c4^x+1,c3^x+1,c2^x+1,c1^x+1)
=c1^x(c2^x(c3^x(c4^x(d^x(9^x+1,b^x+1,c0^x+1,d^x+1,c4^x+1,c3^x+1,c2^x+1,c1^x+1)))))

d^x마지막으로 계산 c4훨씬 더 반복 된 버전이 소요됩니다 d다음 번에. 때 c4^x마지막으로 계산 c3훨씬 더 반복 된 버전을 걸릴 것입니다 c4...
이 반복 때문에 정말 강력한 버전을 생성합니다 d:

  1. b사용 개선c0
  2. c0사용 개선b
  3. 를 사용하여 중첩의 모든 레이어를 b 향상시킵니다. 스스로 개선합니다. 즉, 반복 될 때 d가 더 강력 해집니다.

이 긴 c 체인을 만드는 것이 무엇을 하는가 e(x)=c0^x(x,b,c0,d,c(a(x)),c(a(x)-1),c(a(x)-2),…,c(3),c(2),c(1))[1]. 그냥 줄 것입니다 우회하는
데 사용 c0^x합니다 . 이는 결국의 두 번째 출력을 반환한다는 의미입니다 . 그래서c0d
[1]d^…b^… .

이 시점에서 나는 입력 증가를 제외하고 출력을 크게 늘리기 위해 e (x)와 관련이 있다고 생각할 수 없었습니다.

따라서 f(x,a)=a(x),e(a(x))(x,a)[1](x)용도 b^…에 의해 생성 된 e(x)출력에 더 기재 기능 및 기본 함수를 호출하는 것으로 사용 e(x)큰 입력으로한다.

g(x)=e(x)(x,f)[1](x,a)[1](x)파이널 e(x)을 사용 하여 중첩 f하고 실제로 강력한 기능을 생성합니다.

근사치

이 숫자를 fgh로 근사화하는 데 도움이 필요합니다.

구버전 : f ω ω 6 (f ω ω 5 (9e999)), 온라인으로 사용해보십시오! 설명의 개정 이력


실제로, f_1(x) = x+x그러나 장기적으로는 그렇게 중요하지 않습니다.
Simply Beautiful Art

기본 시퀀스를 조금 더 설명해 주시겠습니까?
Simply Beautiful Art

@SimplyBeautifulArt ow yes에서 변경 한 후 업데이트하는 것을 잊었습니다 x*x.
fejfo

@SimplyBeautifulArt 내 대답은 서수를 사용하지 않으므로 서수로 설명하기가 어렵습니다. 실제로 할 수있는 것은 내 기능의 정의와 fgh의 효과에 대한 근사치를 제공하는 것입니다. 예 :a2(f_n)~=f_{n+1}
fejfo

1

루비, f ε 0 2 (5), 271 바이트

m=->n{x="";(0..n).map{|k|x+="->f#{k}{"};x+="->k{"+"y=#{n<1??k:"f1"};k.times{y=f0[y]};y";(2..n).map{|l|x+="[f#{l}]"};eval x+(n<1?"":"[k]")+"}"*(n+2)}
g=->z{t="m[#{z}]";(0...z).map{|j|t+="[m[#{z-j-1}]]"};eval t+"[->n{n+n}][#{z}]"}
p m[5][m[4]][m[3]][m[2]][m[1]][m[0]][g][6]

온라인으로 사용해보십시오!

이것은 m (n) map을 기반으로합니다 .

설명:

m[0][f0][k] = f0[f0[...f0[k]...]]k의 반복 f0.

m[1][f0][f1][k] = f0[f0[...f0[f1]...]][k]k의 반복 f0.

m[2][f0][f1][f2][k] = f0[f0[...f0[f1]...]][f2][k]k의 반복 f0.

일반적으로 인수를 m[n]취하고 n+2첫 번째 인수를 반복합니다.f0 , k배 번째 인수로하고 세 번째 인자 상에 생성 된 함수를 적용 (존재하는 경우) (존재하는 경우), 그 다음 네 번째 인수 상에 생성 된 함수를 적용 기타

m[0][n↦n+1][3] = (((3+1)+1)+1 = 6

일반적으로 m[0][n↦n+1] = n↦2n.

m[0][m[0][n↦n+1]][3] = m[0][n↦2n][3] = 2(2(2(3))) = 24

일반적으로 m[0][m[0][n↦n+1]] = n↦n*2^n.

m[1][m[0]][3]
= m[0][m[0][m[0][n↦n+1]]][3]
= m[0][m[0][n↦2n]][3]
= m[0][n↦n*2^n][3]
= (n↦n*2^n)[(n↦n*2^n)[n↦n*2^n(3)]]
= (n↦n*2^n)[(n↦n*2^n)[24]]
= (n↦n*2^n)[402653184]
= 402653184*2^402653184

일반적으로 m[1][m[0]][n↦n+1] = f_ω빠르게 성장하는 계층 구조에서.


g[z] = m[z][m[z-1]][m[z-2]]...[m[1]][m[0]][n↦2n][z]

그리고 최종 출력은

m[5][m[4]][m[3]][m[2]][m[1]][m[0]][g][6]
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.