당신의 목표는 숫자를 인쇄하는 프로그램을 작성하는 것입니다. 숫자가 클수록 더 많은 포인트를 얻게됩니다. 그러나 조심하십시오! 스코어링 기능에서 코드 길이는 제한적이며 가중됩니다. 인쇄 된 숫자는 솔루션에 사용한 바이트 수의 큐브 로 나뉩니다 .

인쇄 10000000하고 코드 100길이 가 길 다고 가정 해 봅시다 . 최종 점수는입니다 10000000 / 100^3 = 10.

이 도전을 조금 더 어렵게 만들기 위해 따라야 할 다른 규칙이 있습니다.

• 코드에서 숫자를 사용할 수 없습니다 (0123456789).
• 수학적 / 물리적 / 등을 사용할 수 있습니다 . 상수, 그러나 10보다 작은 경우에만 해당됩니다 (예 : Pi ~ = 3.14를 사용할 수 있지만 Avogadro 상수 = 6e23을 사용할 수 없음 )
• 재귀는 허용 되지만 생성 된 숫자는 유한해야합니다 (따라서 무한 은 솔루션으로 받아 들여지지 않습니다. 무한한 시간과 메모리를 가정하고 요청 된 출력을 생성한다고 가정하면 프로그램이 올바르게 종료되어야합니다).
• 연산을 *(곱하기), /(나누기), ^(파워) 또는 다른 방법으로 2 div 2사용할 수 없습니다 (예 : 허용되지 않음).
• 필요한 경우 프로그램에서 둘 이상의 숫자를 출력 할 수 있습니다 . 가장 높은 점수 만 득점에 포함됩니다.
• 그러나 문자열 을 연결할 수 있습니다. 이는 인접한 숫자의 시퀀스가 ​​단일 숫자로 간주됨을 의미합니다.
• 코드는있는 그대로 실행됩니다. 즉, 최종 사용자는 코드 줄을 편집 할 수 없으며 숫자 나 다른 어떤 것도 입력 할 수 없습니다.
• 최대 코드 길이는 100 바이트입니다.

리더 보드

1. Steven H. , Pyth ≈ f _{φ (1,0,0) +7} (256 ²⁶ ) / 1000000 ^[1]
2. 단순히 아름다운 예술 , 루비 ≈ f _{φ 121 (ω)} (126) ^[1]
3. 피터 테일러 , GolfScript ≈ f _{ε 0 + ω + 1} (17) / 1000 ^[1]
4. 입술 , GolfScript ≈ F _{ε 0} (F _{ε 0} (F _{ε 0} (F _{ε 0} (F _{ε 0} (F _{ε 0} (F _{ε 0} (F _{ε 0} (F _{ε 0} (126))))))))) ^[1]
5. 단순히 아름다운 예술 , 루비 ≈ f _{ω ^ω2 +1} (1983)
6. eaglgenes101 , Julia ≈ f _ω3 (127)
7. col6y , Python 3, ≈ (127 → 126 → ... → 2 → 1) / 99 ^{3 [1] [3]}
8. Toeofdoom 하스켈, ≈ ₂₀ (1) / 99 ^{3 [1]}
9. Fraxtil , dc, ≈ 15 ↑ ¹⁶⁶⁶⁶⁶⁵ 15/100 ^{3 [3]}
10. 마젠타 , 파이썬 ≈ ACK (126,126) / 100 ⁽³⁾ ≈ ↑ 10 ¹²⁴ 129
11. 켄달 프레이 , ECMAScript를 6 ≈ 10 ^{3 ↑ 4 (3)} / 100 ^{(3) [1]}
12. Ilmari Karonen , GolfScript, ≈ 10 ↑ ³ 10 ³⁷⁷ / 18 ^{3 [1]}
13. BlackCap , Haskell, ≈ 10 ↑↑ 65503 / 100 ³
14. 재귀 , 파이썬, ≈ 2 ↑↑ 11 / 95 ³ ≈ 10 ↑↑ 8.63297 ^{[1] [3]}
15. nm , 하스켈, ≈ 2 ↑↑ 7 / 100 ³ ≈ 10 ↑↑ 4.63297 ^[1]
16. 데이비드 요우 , C, ≈ 10 ^{10 4 × 10 22} / 83 ³ ≈ 10 ↑↑ 4.11821 ^[2]
17. 프리모 , 펄, ≈ 10 ^{(12,750,684,161!) 5 2 × 27} / 100 ⁽³⁾ ≈ 4.11369 10 ↑↑
18. 아트 , C, ≈ 10 ^{10 2 10 × 6} / 98 ⁽³⁾ ≈ 3.80587 10 ↑↑
19. 로버트 Sørlie , 86, ≈ 10 ^{2 2 19 32} / 100 ³ ≈ 10 ↑↑ 3.71585
20. Tobia , APL, ≈ 10 ^{10 353} / 100 ⁽³⁾ ≈ 3.40616 10 ↑↑
21. 대런 스톤 , C, ≈ 10 ^{10 97.61735} / 98 ³ ≈ 10 ↑↑ 3.29875
22. ecksemmess , C, ≈ 10 ^{2 320} / 100 ⁽³⁾ ≈ 3.29749 10 ↑↑
23. 아담 Speight , vb.net, ≈ 10 ^{5000 × (2 (64) ) 4} / 100 ³ ≈ 3.28039 10 ↑↑
24. 조슈아 배쉬, ≈ 10 ^{10 15} / 86 ³ ≈ 3.07282 10 ↑↑

_각주

1. ^{만약 우주의 모든 전자가 큐비 트이고 그것의 모든 중첩이 정보를 저장하는 데 능숙하게 사용될 수 있다면 (저장되는 것을 실제로 알 필요가 없다면 이론적으로 가능합니다),이 프로그램은 가능한 것보다 더 많은 메모리를 필요로합니다 현재 또는 미래의 상상할 수있는 시점에 존재할 수 있으므로 실행이 불가능합니다. 작성자가 ≈3 ↑↑ 3.28보다 큰 값을 한 번에 인쇄하려는 경우이 조건이 적용됩니다.}
2. ^{이 프로그램은 현재 존재하는 것보다 더 많은 메모리를 필요로하지만 이론적으로는 적은 수의 큐빗에 저장 될 수 없을 정도로 많지 않으므로이 프로그램을 실행할 수있는 컴퓨터가 언젠가 존재할 수 있습니다.}
3. ^{현재 사용 가능한 모든 통역사가 런타임 오류를 발생 시키거나 그렇지 않으면 프로그램이 작성자가 의도 한대로 실행되지 않습니다.}
4. ^{이 프로그램을 실행하면 시스템이 복구 할 수없는 손상을 입을 수 있습니다.}

@primo 편집 : 다음 높은 거듭 제곱까지의 로그 거리를 나타 내기 위해 소수를 사용하여 비교하기 쉬운 표기법을 사용하여 스코어 보드의 일부를 업데이트했습니다. 예를 들어 10 ↑↑ 2.5 = 10 ^{10 √10} 입니다. 또한 사용자의 분석이 잘못되었다고 생각되면 점수를 변경했습니다.

이 표기법에 대한 설명 :

만약 0 ≤ b < 1다음, .a↑↑b = ab

만약 b ≥ 1다음, .a↑↑b = aa↑↑(b-1)

만약 b < 0다음, .a↑↑b = loga(a↑↑(b+1))

GolfScript; 최소 f _{ε_0 + ω + 1} (17) / 1000 이상

이 질문 에 대해 웜 답변 의 수명 을 사용 하겠다는 res 의 제안에 따라 Howard의 솔루션 파생을 크게 향상시키는 두 가지 프로그램을 제시합니다.

그것들은 공통 접두사를 공유하고 함수 이름을 모듈로합니다.

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g

대략 f _{ε 0} 으로 증가 하는 g(g(1)) = g(5)위치를 계산 합니다 (해석은 "Goodstein 함수와 거의 동일한 속도로 성장 하는 빠르게 성장하는 계층 구조의 함수"입니다).g(x) = worm_lifetime(x, [x])

분석하기가 조금 더 쉽습니다 (!)

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{.{.{.{.{.{.{.{.{.{g}*}*}*}*}*}*}*}*}*}*

.{foo}*에 매핑 x됩니다 foo^x x.

,:z){[]+z\{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{g}*

따라서 g^(g(5)) ( g(5) ); 추가 8 단계 반복은 화살표 체인과 유사합니다. 간단한 용어로 표현하려면 다음 h_0 = g과 h_{i+1} (x) = h_i^x (x)같이 계산 h_10 (g(5))합니다.

이 두 번째 프로그램은 거의 확실히 점수가 더 높다고 생각합니다. 이번에는 기능에 할당 된 레이블이 g개행 (sic)입니다.

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:
~
{.['.{
}*'n/]*zip n*~}:^~^^^^^^^^^^^^^^^^

이번에 ^는 다른 기능으로 더 잘 사용 합니다.

.['.{
}*'n/]*zip n*~

소요 x스택, 잎 x포함 된 문자열 다음 x의 복사본 .{이어서 의해 g다음 x의 복사 }*; 그런 다음 문자열을 평가합니다. 여분의 캐릭터를 구울 수있는 더 좋은 곳이 있었으므로 시작하겠습니다 j_0 = g. 그렇다면 계산 j_{i+1} (x) = j_i^x (x)의 첫 번째 평가 (이미 이미 이전 프로그램을 능가 한다고 확신합니다). 그런 다음 16 번 더 실행합니다 . 그렇다면 and 을 계산 합니다. >> f _{ε_0 + ω + 1} (i) 를 평가 해 _주셔서 다시 한 번 감사드립니다 .^j_{g(5)} (g(5))^k_0 = g(5)k_{i+1} = j_{k_i} (k_i)k_17k_i

Windows 2000-Windows 8 (3907172 / 23³ = 321)

참고 : 이 기능을 실행하지 마십시오!

다음을 배치 파일에 저장하고 관리자 권한으로 실행하십시오.

CD|Format D:/FS:FAT/V/Q

첫 번째 인쇄 번호가 굵게 표시된 4TB 드라이브에서 실행될 때 출력됩니다.

드라이브 D :에 새 디스크를
넣고 준비가되면 ENTER를 누르십시오 ... 파일 시스템의 유형은 NTFS입니다.
새로운 파일 시스템은 FAT입니다.
빠른 포맷 3907172M
볼륨이 FAT16 / 12에 비해 너무 큽니다.

GolfScript, 점수 : 방법 을 너무 많이

몇 개의 GolfScript 문자로 얼마나 많은 숫자를 인쇄 할 수 있습니까?

다음 코드로 시작하겠습니다 ( 감사합니다! Ben! ) 126.

'~'(

다음으로 126 회 반복하여 약 1.26126 × 10 ³⁷⁷ 과 같은 숫자를줍니다 .

'~'(.`*

(곱셈이 아닌 문자열 반복이므로 규칙에 따라 괜찮습니다.)

이제 378 자리 숫자를 10 ³⁷⁷ 번 조금 반복 합니다 .

'~'(.`*.~*

이 프로그램은 실제로 약 10 ³⁸⁰ ≈ 2 ¹¹⁴⁰ 자릿수의 숫자 를 계산하려고하기 때문에이 프로그램이 끝나는 것을 볼 수 없습니다 . 어떤 컴퓨터도 그렇게 큰 숫자를 저장할 수 없으며, 알려진 물리를 사용하여 그러한 컴퓨터를 만들 수도 없습니다. 관찰 우주에있는 원자의 수는 약 10로 추정되는 ⁸⁰ , 그래서 우리는 어떻게 든 사용할 수있는 경우에도 우주의 모든 문제를 이 거대한 수를 저장하기 위해, 우리는 여전히 어떻게 든 벼락 공부를해야 할 것 10 ⁽³⁸⁰⁾ / 10 ⁽⁸⁰⁾ = 10 ⁽³⁰⁰⁾ 에 자리 각 원자!

그러나 우리에게 그러한 계산을 수행 할 수있는 하나님 자신의 GolfScript 인터프리터가 있고 여전히 만족스럽지 않다고 가정합시다. 좋아, 다시 해보자!

'~'(.`*.~*.~*

이 프로그램의 출력이 완료 될 경우 약 10 ^{10 383} 자리가되므로 약 10 ^{10 10 383} 과 같습니다 .

하지만 기다려! 그 프로그램은 반복적으로 진행되고 있습니다. 왜 우리는 루프로 전환하지 않습니까?

'~'(.`*.{.~*}*

여기서 루프 바디는 약 10 ³⁷⁷ 번 실행되어 약 10 10 ^{× 10 377} 자릿수 로 구성된 이론적 출력을 제공합니다. 여기서 10 의 반복 전력 타워 는 약 10 ³⁷⁷ 단계 길이입니다. (실제로, 반복되는 숫자가 매번 더 길어 지지만 상대적으로 말하면 사소한 문제라는 사실을 무시하고 있기 때문에 실제로는 과소 평가됩니다.)

그러나 아직 끝나지 않았습니다. 다른 루프를 추가합시다!

'~'(.`*.{.{.~*}*}*

그러한 숫자 의 근사값 을 제대로 적어 두기 위해서는 난해한 수학 표기법이 필요합니다. 예를 들어 Knuth 위쪽 화살표 표기법 에서 위의 프로그램에 의해 출력 된 숫자 (이론적으로)는 약 10 ↑ ³ 10 ³⁷⁷ 이어야하며 수학을 올바르게했다고 가정 할 때 10의 거듭 제곱을 주거나 가져야합니다 (또는 10 ³⁷⁷ ).

이와 같은 숫자는 "믿을 수 없을 정도로 큰 것"을 넘어 "생각할 수없는"영역으로 넘어갑니다. 마찬가지로, 그러한 숫자를 세거나 적는 것은 불가능할뿐만 아니라 (위의 세 번째 예에서 이미 그 시점을 넘어 섰습니다) 문자 그대로 추상 수학 밖에서 생각하거나 사용할 수 없습니다. 우리는에서, 증명할 수있는 수학의 공리 와 같은 숫자는 우리가 위의 프로그램 GolfScript 사양에서 증명할 수있는 것처럼, 존재, 것 ) 현실과 사용 가능한 저장 공간의 한계가 개입하지 않은 경우를 계산하지만, 문자 그대로 없다 아무것도 에 어떤 의미에서든 계산하거나 측정하는 데 사용할 수있는 물리적 우주.

여전히 수학자들은 때때로 더 많은 수를 사용 합니다 . (이론적으로) 큰 계산 수 는 조금 더 많은 작업을 필요로합니다. 더 많은 루프를 하나씩 중첩하는 대신 재귀를 사용 하여 중첩 된 루프 의 깊이 를 망원경으로 사용해야 합니다. 그럼에도 불구하고 원칙적으로 Conway 체인 화살표 표기법으로 표현할 수있는 숫자를 (이론적으로) 계산하기 위해 짧은 GolfScript 프로그램 (100 바이트 미만)을 작성할 수 있어야합니다 . 세부 사항은 연습으로 남습니다. ;-)

자바 스크립트 44 자

이것은 약간 건방진 것처럼 보일 수 있습니다.

alert((Math.PI+''+Math.E).replace(/\./g,""))

점수 = 31415926535897932718281828459045 / 44 ^ 3 ≈ 3.688007904758867e + 26 ≈ 10 ↑↑ 2.1536134004

C, 점수 = 10 ^{10 97.61735} / 98 ³ ≈ 10 ↑↑ 2.29874984

unsigned long a,b,c,d,e;main(){while(++a)while(++b)while(++c)while(++d)while(++e)printf("%lu",a);}

득점에 도움을 주셔서 감사합니다. 모든 통찰력이나 수정을 부탁드립니다. 내 방법은 다음과 같습니다.

n = 1에서 2 ⁶⁴ -1 까지 의 모든 숫자 의 연결로 (2 ⁶⁴ -1)을 ⁴ 번 반복 합니다. I가있어 추정 방법 우선, 여기에 (저) 1 내지 2 자릿수 누적 ⁶⁴ -1 (이하 "서브") 서브 시퀀스 시퀀스의 마지막 번호 2 ⁽⁶⁴⁾ -1 = 1844674407370955161520 자리. 따라서 하위 시퀀스의 숫자 ( 1..로 시작하는 숫자)의 90 % 이상 9이 19 자리입니다. 나머지 10 %는 평균 10 자리라고 가정합니다. 그것은 그것보다 훨씬 많을 것이지만, 이것은 쉬운 수학과 부정 행위에 대한 낮은 추정치입니다. 즉, 시퀀스 (2 반복 도착 ⁶⁴ -1) ⁴ 회이므로 길이의 n 은 적어도 (0.9 × (2 ⁽⁶⁴⁾ -1) 19 + 0.1 × (2 × ⁶⁴ × (2-1)이 10 ×) ⁽⁶⁴⁾ -1) ⁽⁴⁾ = 3.86613 × 10 ⁹⁷ 자리. 아래 주석에서 @primo는 n 의 길이 가 4.1433x10 ⁹⁷ 임을 확인합니다 . 따라서 n 자체는 ^{10의 거듭 제곱} 이거나 10 ^{10 97.61735} 입니다.

l = 98 자

점수 = 해당 없음 ³ = 10 ^{10 97.61735} / 98 ³

요구 사항 : 64 비트 컴퓨터에서 실행해야합니다 sizeof(long) == 8. Mac과 Linux가 그렇게 할 것입니다.

파이썬 3-99 문자-Graham의 수보다 훨씬 큽니다.

Ackermann 기능의 확장을 기반으로 더욱 빠르게 기능을 향상 시켰습니다.

A=lambda a,b,*c:A(~-a,A(a,~-b,*c)if b else a,*c)if a else(A(b,*c)if c else-~b);A(*range(ord('~')))

http://fora.xkcd.com/viewtopic.php?f=17&t=31598 나에게 영감을 주었지만 내 번호를 이해하기 위해 거기를 볼 필요는 없습니다.

분석에 사용할 ackermann 함수의 수정 된 버전은 다음과 같습니다.

A(b)=b+1
A(0,b,...)=A(b,...)
A(a,0,...)=A(a-1,1,...)
A(a,b,...)=A(a-1,A(a,b-1,...),...)

내 기능 A위의 코드에서 은 기술적으로 동일하지 않지만 위 정의의 세 번째 줄을 대체하는 다음 명령문으로 실제로 더 강력합니다.

A(a,0,...)=A(a-1,a,...)

(a는 1 이상이어야하므로 더 강해야 함)

그러나 내 목적을 위해 분석이 Ackermann의 기능에 대해 이미 부분적으로 수행 되었으므로이 기능에 대해 두 가지 인수가있을 때 더 간단한 것으로 가정합니다.

내 함수는 항상 다음 중 하나 때문에 인수 재귀를 중지합니다. 인수를 제거하거나 첫 번째 인수를 줄이거 나 동일한 첫 번째 인수를 유지하고 두 번째 인수를 줄입니다.

크기 분석

Graham의 번호 AFAIK는 다음을 G(64)사용하여 나타낼 수 있습니다 .

G(n) = g^n(4)
g(n) = 3 ↑^(n) 3

어디 ↑^(n) b는 knuth의 위쪽 화살표 표기법입니다.

게다가:

A(a,b) = 2 ↑^(a-2) (b+3) - 3
A(a,0) ≈ 2 ↑^(a-2) 3
g(n) ≈ A(n+2,0) // although it will be somewhat smaller due to using 2 instead of 3. Using a number larger than 0 should resolve this.
g(n) ≈ A(n+2,100) // this should be good enough for my purposes.

g(g(n)) ≈ A(A(n+2,100),100)

A(1,a+1,100) ≈ A(0,A(1,a,100),100) = A(A(1,a,100),100)

g^k(n) ≈ A(A(A(A(...(A(n+2,100)+2)...,100)+2,100)+2,100)+2,100) // where there are k instances of A(_,100)
A(1,a,100) ≈ A(A(A(A(...(A(100+2),100)...,100),100),100),100)

g^k(100) ≈ A(1,k,100)
g^k(4) < A(1,k,100) // in general
g^64(4) < A(1,64,100)

위 프로그램에 표시된 숫자는 A(0,1,2,3,4,...,123,124,125) 입니다.

g^64(4)Graham의 숫자 이므로 수학이 정확하다고 가정하면 이보다 작습니다 A(1,64,100). 내 숫자는 Graham의 숫자보다 훨씬 큽니다.

내 수학에서 실수를 지적하십시오.없는 경우이 질문에 대답하기 위해 지금까지 계산 된 가장 큰 숫자 여야합니다.

펄-≈ 10 ↑↑ 4.1

$_=$^Fx($]<<-$]),/(?<R>(((((((((((((((((((.(?&R))*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

다시 한번 Perl의 정규식 엔진을 남용하여 상상할 수없는 양의 조합을 연마하고, 이번에는 재귀 강하를 사용합니다.

표현의 대부분에서 맨손으로 . 무한 재귀를 방지하여 재귀 수준을 문자열 길이로 제한하는 방법은 없습니다.

우리가 끝내는 것은 이것입니다.

/((((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*/
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                    .                                      \
                       .
                       .

... 총 12750684161 개의 중첩에 대해 671088640 번 반복 -이전의 23 번 시도를 상당히 철저하게합니다. 중첩을 가 수치스럽게 나타납니다. 놀랍게도, perl은 이것에 질식하지 않습니다 (다시 한번, 메모리 사용량은 약 1.3GB로 유지됩니다). 첫 번째 print statement가 발행되기까지는 꽤 오랜 시간이 걸립니다.

아래에있는 내 이전 분석에서, 숫자 출력의 수의 순서에있을 것이라고 결론을 내릴 수있다 (! 12750684161) ^671088640 , k는! 는 IS 왼쪽 계승 의 K (참조 A003422을 ). 이것을 (k-1) 로 근사 할 수 있습니다 ! 이 값은 엄밀히 작지만 크기는 같습니다.

그리고 우리가 wolframalpha에게 물어 보면 :

... 내 점수가 거의 변하지 않습니다. 나는 그것이 적어도 10 ↑↑ 5 일 것이라고 생각했다 . 10 ↑↑ 4 와 10 ↑↑ 4.1 의 차이가 생각보다 훨씬 큽니다.

펄-≈ 10 ↑↑ 4

$_=$^Fx($]<<-$]),/((((((((((((((((((((((.*.*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

펄 정규식 엔진을 사용하여 몇 가지 조합 작업을 수행합니다. 임베디드 코드 블록
(??{print})은 결과를 정규식에 직접 삽입합니다. 이후 $_의 전체 구성되어 2의 (그리고 결과는 print항상 1)이 일치하지 않으며, 꽤 거기에있는 모든 가능한 조합을 통해 회전 펄을 전송 않을 수 있습니다.

사용 된 상수

• $^F-최대 시스템 파일 핸들. 일반적으로 2.
• $]-펄 버전 번호 5.016002.

$_ 그런 다음 숫자를 포함하는 문자열입니다 2 671088640 번 반복 입니다. 메모리 사용량은 약 1.3GB로 일정하며 출력이 즉시 시작됩니다.

분석

의 정의하자 P의 _K (N)를 인쇄 문을 실행 횟수로 k는 스팅의 수이고, n은 내가 쓰는 기분이 안 이유만으로 문자열의 길이를 더한이다 ( N + 1 어디에나).

(.*.*)*
P ₂ (n) = [ 2, 8, 28, 96, 328, 1120, 3824, 13056, ... ]

((.*.*)*)*
P ₃ (n) = [ 3, 18, 123, 900, 6693, 49926, 372615, 2781192, ... ]

(((.*.*)*)*)*
P ₄ (n) = [ 4, 56, 1044, 20272, 394940, 7696008, 149970676, 2922453344, ... ]

((((.*.*)*)*)*)*
P ₅ (n) = [ 5, 250, 16695, 1126580, 76039585, 5132387790, 346417023515, 23381856413800, ... ]

(((((.*.*)*)*)*)*)*
P ₆ (n) = [ 6, 1452, 445698, 137050584, 42142941390, 12958920156996, ... ]

((((((.*.*)*)*)*)*)*)*
P ₇ (n) = [ 7, 10094, 17634981, 30817120348, 53852913389555, ... ]

일반적으로 공식은 다음과 같이 일반화 할 수 있습니다.

어디

즉, 인 왼쪽 요인 의 K 미만의 모든 계승의 합, 즉, K (참조 A003422을 ).

나는 닫힌 형태를 결정하지 못하고 한 D의 _K 와 E의 _K를 , 우리가 그것을 관찰하면 너무 중요하지 않습니다.

과

23 개의 중첩을 사용 하면 대략적인 점수를 얻습니다.

이것은 실제로 거의 정확해야합니다.

그러나 이것을 좀 더 시각화하기 쉬운 표기법으로 만들기 위해 내부 지수의 밑을 근사화 할 수 있습니다.

그리고 지수 자체 :

다음 울프 럼 알파 물어 :

10 ↑↑ 4로 전화 하면됩니다.

자바 스크립트, 10 ↑↑↑↑ 210

100 자

z=~~Math.E+'';o={get f(){for(i=z;i--;)z+=i}};o.f;for(i=z;i--;)for(j=z;j--;)for(k=z;k--;)o.f;alert(z)

최대한 반복하는 관찰을 바탕으로 f갈 수있는 최적의 방법, 난에 13 개 통화 대체 f통화 중첩 루프의 3 개 수준 f, z동안 (배 각각 f증가 계속z ).

나는 한 장의 종이에서 점수를 분석적으로 추정했습니다. 누군가가 그것을보고 싶어한다면 그것을 입력하겠습니다.

점수 향상 : 10 ↑↑ 13

정확히 100 자로 된 자바 스크립트 :

z=~~Math.E+'';__defineGetter__('f',function(){for(i=z;i--;)z+=i});f;f;f;f;f;f;f;f;f;f;f;f;f;alert(z)

이렇게하면 세 가지 방법으로 원래의 답변이 향상됩니다.

1. z글로벌 범위를 정의 하면 o.z매번 입력하지 않아도됩니다 .

2. 전역 범위 (창)에서 getter를 정의하고 f대신 유형을 정의 할 수 있습니다 o.f.

3. 더 많은 반복을 갖는 것은 f그래서 대신, 큰 숫자로 시작하는 것보다 더 가치가있다 (Math.E+'').replace('.',''), 그것은 사용하는 것이 좋습니다 (= 2718281828459045 27 개 문자) ~~Math.E+''(= 2, 11 개 문자)을 호출 할인양 문자를 사용하는 f더 많은 시간을.

아래에서 추가로 분석되는 것처럼 각 반복은 M 의 차수에서 10 ^M 의 차수보다 큰 숫자를 생성하므로이 코드는 각 반복 후에 생성됩니다.

1. 210 ~ O (10 ² )
2. O (10 ^{10 2} ) ~ O (10 ↑↑ 2)
3. O (10 ^{10 ↑↑ 2} ) = O (10 ↑↑ 3)
4. O (10 ^{10 ↑↑ 3} ) = O (10 ↑↑ 4)
5. O (10 ^{10 ↑↑ 4} ) = O (10 ↑↑ 5)
6. O (10 ^{10 ↑↑ 5} ) = O (10 ↑↑ 6)
7. O (10 ^{10 ↑↑ 6} ) = O (10 ↑↑ 7)
8. O (10 ^{10 ↑↑ 7} ) = O (10 ↑↑ 8)
9. O (10 ^{10 ↑↑ 8} ) = O (10 ↑↑ 9)
10. O (10 ^{10 ↑↑ 9} ) = O (10 ↑↑ 10)
11. O (10 ^{10 ↑↑ 10} ) = O (10 ↑↑ 11)
12. O (10 ^{10 ↑↑ 11} ) = O (10 ↑↑ 12)
13. O (10 ^{10 ↑↑ 12} ) = O (10 ↑↑ 13)

점수 : ~ ^{10 10 10 10 10 16} ≈ 10 ↑↑ 6.080669764

정확히 100자인 자바 스크립트 :

o={'z':(Math.E+'').replace('.',''),get f(){i=o.z;while(i--){o.z+=i}}};o.f;o.f;o.f;o.f;o.f;alert(o.z)

각각 o.fwhile 루프를 호출하여 총 5 개의 루프를 만듭니다. 첫 번째 반복 후에 만 ​​점수는 이미 10 ^{42381398144233621} 이상 입니다. 두 번째 반복으로 Mathematica는 결과 의 자릿수 조차 계산할 수 없었습니다 .

다음은 코드 연습입니다.

초기화

에서 소수점을 제거하여 2718281828459045로 시작하십시오 Math.E.

반복 1

감소하는 숫자의 순서를 연결

• 2718281828459045
• 2718281828459044
• 2718281828459043
• ...
• 삼
• 2
• 1
• 0

새로운 (거대한) 숫자를 형성하기 위해

• 271828182845904527182818284590442718281828459043 ... 9876543210.

이 숫자는 몇 자리입니까? 글쎄, 그것은 연결

• 1718281828459046 16 자리 숫자
• 900000000000000 15 자리 숫자
• 90000000000000 14 자리 숫자
• 9000000000000 13 자리 숫자
• ...
• 900 3 자리 숫자
• 90 2 자리 숫자
• 1 자리 숫자 10 개

Mathematica에서

In[1]:= 1718281828459046*16+Sum[9*10^i*(i+1),{i,-1,14}]+1
Out[1]= 42381398144233626

즉, 2.72⋅10 ^{42381398144233625입니다.} 입니다.

첫 번째 반복 후에 만 ​​내 점수 만들기, 2.72⋅10 ^{42381398144233619} .

반복 2

그러나 그것은 시작에 불과합니다. 이제 거대한 숫자부터 시작 하여 단계를 반복하십시오 ! 즉, 숫자의 내림차순을 연결하고

• 271828182845904527182818284590442718281828459043 ... 9876543210
• 271828182845904527182818284590442718281828459043 ... 9876543209
• 271828182845904527182818284590442718281828459043 ... 9876543208
• ...
• 삼
• 2
• 1
• 0

그래서, 나의 새로운 점수는 무엇입니까, Mathematica?

In[2]:= 1.718281828459046*10^42381398144233624*42381398144233625 + Sum[9*10^i*(i + 1), {i, -1, 42381398144233623}] + 1

During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>

During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>

Out[2]= Overflow[]

반복 3

반복.

반복 4

반복.

반복 5

반복.

분석 점수

첫 번째 반복에서 우리는 2718281828459045에서 시작하는 감소 시퀀스의 연결에서 자릿수를 계산하여 자릿수를 계산했습니다.

• 1718281828459046 16 자리 숫자
• 900000000000000 15 자리 숫자
• 90000000000000 14 자리 숫자
• 9000000000000 13 자리 숫자
• ...
• 900 3 자리 숫자
• 90 2 자리 숫자
• 1 자리 숫자 10 개

이 합계는 공식으로 나타낼 수 있습니다.

여기서 Z 는 시작 번호 ( 예 : 2718281828459045)를 나타내고 O _Z 는 그 크기 차수를 나타냅니다 ( 예 : Z ∼ 10 ¹⁵ 이기 때문에 ¹⁵ ). 유한 합에 동등성을 사용 하면 위와 같이 명시 적으로 표현할 수 있습니다.

우리가 9 ≈ 10을 취하면

마지막으로, 용어의 순서를 줄임으로써 용어를 확장하고 순서를 정하면

이제 우리는 결과의 크기 순서에만 관심이 있기 때문에 Z 를 " O _Z 의 크기 순서의 숫자로 대체합시다. " 즉, 10 ^{O _Z} -

마지막으로, 두 번째 및 세 번째 용어는 취소되고 마지막 두 용어는 삭제 될 수 있습니다 (그들의 크기는 사소합니다).

여기서 첫 번째 항이 승리합니다.

일러스트레이션, f 는 M 의 차수의 숫자를 취하고 대략 M 의 차수 (10 ^M ) 의 숫자를 생성합니다 .

첫 번째 반복은 손으로 쉽게 확인할 수 있습니다. 2718281828459045는 15 정도의 f숫자 이므로 15 (10 ¹⁵ ) ~ 10 ¹⁶ 정도의 숫자를 생성해야합니다. . 실제로, 생성 된 수는 이전부터 2.72⋅10 ^{42381398144233625,} 즉 10 ^{42381398144233625} ∼ 10 ^{10 16입니다.} 이다.

그것을 지적 M 이 M (10 ^M ) 에서 중요한 요소가 아니라는 , 각 반복의 결과의 크기 순서는 간단한 패턴 화를 따릅니다.

1. 10 ¹⁶
2. 10 ^{10 16}
3. 10 ^{10 10 16}
4. 10 ^{10 10 10 16}
5. 10 ^{10 10 10 10 16}

LaTeX 소스

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\sum_{k=0}^{\mathcal{O}_Z-1}{(9\cdot10^k(k+1))}+1

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\frac{10-\mathcal{O}_Z10^{\mathcal{O}_Z}+(\mathcal{O}_Z-1)10^{\mathcal{O}_Z+1}}{9}+10^{\mathcal{O}_Z}

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+1

Z\mathcal{O}_Z+Z-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2

\mathcal{O}_Z10^{\mathcal{O}_Z}+10^{\mathcal{O}_Z}-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2

\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}

APL, 10 ↑↑ 3.4

여기 수정 된 시도가 있습니다.

{⍞←⎕D}⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⊢n←⍎⎕D

현재 하드웨어에서 실행되는 100 자 / 바이트 * 프로그램 (소량의 메모리 및 일반 32 비트 int 변수 사용)은 완료하는 데 시간이 오래 걸립니다.

실제로 APL 인터프리터에서 실행할 수 있으며 숫자 인쇄가 시작됩니다. 완료가 허용되면 10 × 123456789 ⁴⁴ 자리의 숫자 가 인쇄 됩니다.

따라서 점수가 10 ^{× 10 123456789 44} / 100 ⁽³⁾ ≈ 10 ^{10 353} ≈ 10 ↑↑ 3.406161

설명

• ⎕D 미리 정의 된 상수 문자열과 같습니다. '0123456789'
• n←⍎⎕Dn 을 해당 문자열로 표시되는 숫자로 정의 합니다. 123456789 (<2 ³¹ 임) 이므로 루프 제어 변수로 사용할 수 있음)
• {⍞←⎕D} 줄 바꿈없이 10 자리를 표준 출력으로 인쇄합니다.
• {⍞←⎕D}⍣n그것을 n 번 할 것입니다 (⍣ "power operator": *, / 또는 ^는 아닙니다. 수학 연산이 아니기 때문에 일종의 루프입니다)
• {⍞←n}⍣n⍣n이전 작업을 n 번 반복 하므로 10 자리를 인쇄합니다. n ² 번
• {⍞←n}⍣n⍣n⍣n그것을 할 것입니다 n ³ 번
• 나는 ⍣n거기 에 44 를 넣을 수 있으므로 문자열의 n ⁴⁴ 배를 인쇄 합니다 '0123456789'.

^{* : APL 기호를 상위 128 바이트 값에 매핑하는 자체 (레거시) 단일 바이트 문자} 집합으로
^{APL을 작성할 수 있습니다. 따라서 스코어링을 위해 ASCII 문자와 APL 기호 만 사용하는 N 문자 프로그램은 N 바이트 길이로 간주 될 수 있습니다.}

하스켈, 점 (2 ^{2 2 65536} -3) / 1000000 ≈ 2 ↑↑ 7 ≈ 10 ↑↑ 4.6329710779

o=round$sin pi
i=succ o
q=i+i+i+i
m!n|m==o=n+i
 |n==o=(m-i)!i
 |True=(m-i)!(m!(n-i))
main=print$q!q

이 프로그램은 정확히 100 바이트의 순수한 Haskell 코드입니다. 그것은 네 번째 Ackermann 수를 인쇄하여 결국 우주의 모든 가용 에너지, 물질 및 시간을 그 과정에서 소비합니다 (따라서 소프트 한계 5 초 를 약간 초과 함).

Python, 2 ↑↑ 11 / 830584 ≈ 10 ↑↑ 8.632971 (Knuth 위쪽 화살표 표기법)

print True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<True<<True)))))))))

아마도이 컴퓨터를 성공적으로 실행하기에 충분한 메모리를 가진 컴퓨터는 없지만 실제로는 프로그램의 결함이 아닙니다. 최소 시스템 요구 사항이 충족되면 작동합니다.

예, 이것은 부울 값에서 비트 이동을 수행하는 것입니다. 이 맥락에서 True강요됩니다 1. 파이썬은 임의의 길이 정수를 가지고 있습니다.

GolfScript 3.673e + 374

'~'(.`*

나는 그것이 *곱셈이 아니라 문자열 반복을 나타 내기 때문에 허용된다고 생각합니다 .

설명 : '~'(스택에 126 (ASCII 값 "~")을 그대로 둡니다. 그런 다음 숫자를 복사하여 문자열로 변환 한 다음 문자열을 126 번 반복합니다. 이것은 126126126126...대략 어느 것을 제공합니다 1.26 e+377. 해답은 7 자이므로 7^3점수로 약3.673e+374

루비, 확률 적으로 무한대, 54 자

x='a'.ord
x+=x while x.times.map(&:rand).uniq[x/x]
p x

x는 97로 초기화됩니다. 다음 절차를 반복합니다. 0과 1 사이의 x 난수를 생성합니다. 모두 같으면 x를 종료하고 인쇄하십시오. 그렇지 않으면 x를 두 번 반복하십시오. Ruby의 난수는 17 자리의 정밀도를 갖기 때문에 모든 단계에서 종료 될 확률은 1 in (10e17) ^ x입니다. 따라서 n 단계 내에서 종료 될 확률은 x = 1 대 (1 / 10e17) ^ (2 ^ n)의 n에 대한 합이며 1 / 10e34로 수렴합니다. 이것은 아무리 많은 수에 관계없이이 프로그램이 더 적은 수를 출력 할 가능성이 거의 없다는 것을 의미합니다.

물론 철학적 의문은 10 ^ 34의 1보다 적은 n을 단계 n으로 종료 할 수있는 프로그램이 어떤 n에 대해서도 종료 될 수 있는지 여부입니다. 무한한 시간과 힘뿐만 아니라 프로그램에 종료 확률이 감소하는 속도를 초과하는 속도로 속도를 증가시킬 수 있다고 가정하면 실제로는 시간 t에 의해 임의로 1에 가깝게 종료됩니다 .

GolfScript, ≈ f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126))))))))

이것은 @Howard의 다른 답변 에서 뻔뻔스럽게 조정 되었으며 @Peter Taylor의 제안을 통합합니다.

[[[[[[[[[,:o;'~'(]{o:?~%{(.{[(]{:^o='oo',$o+o=<}{\(@\+}/}{,:^}if;^?):?)*\+.}do;?}:f~]f]f]f]f]f]f]f]f

GolfScript에 대한 이해는 제한적이지만 위 의 *및 ^연산자 는 OP에서 금지 된 산술 연산자 가 아니라고 생각합니다 .

(@Howard가 자신의 버전을 제출하고 싶다면 의심 할 여지 없이이 버전보다 우수합니다.)

이 프로그램은 대략 f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126)))))) )))-f _{ε 0} 의 9 번 반복 -f _{ε 0} 은 Goodstein 함수와 거의 같은 속도로 빠르게 성장하는 계층 구조의 함수입니다. (에프 _{ε 0}Friedman의 n (k) 함수와 k- 폴드 Conway 체인 화살표의 성장률이 단지 하나의 인용되지 않은 f _{ε 0} 과 비교할 때조차도 거의 중요하지 않을 정도로 빠르게 성장합니다 .)

dc, 100 자

[lnA A-=ilbA A-=jlaSalbB A--SbLndB A--SnSnlhxlhx]sh[LaLnLb1+sbq]si[LbLnLasbq]sjFsaFsbFFFFFFsnlhxclbp

충분한 시간과 메모리가 주어지면 약 15 ↑ ¹⁶⁶⁶⁶⁶⁵⁵ 15 정도의 숫자를 계산합니다. 원래 하이퍼 연산 기능을 구현 했지만이 도전 과제에 너무 많은 문자가 필요했기 때문에 n = 2, b = 0and n >= 3, b = 0조건을 제거 하고 n = 1, b = 0조건을n >= 1, b = 0 .

여기에 사용 된 유일한 산술 연산자는 덧셈과 뺄셈입니다.

편집 : 의견에서 약속 했듯이이 코드의 기능에 대한 분석은 다음과 같습니다.

[            # start "hyperoperation" macro
lnA A-=i     # if n == 0 call macro i
lbA A-=j     # if b == 0 call macro j
laSa         # push a onto a's stack
lbB A--Sb    # push b-1 onto b's stack
LndB A--SnSn # replace the top value on n with n-1, then push n onto n's stack
lhxlhx       # call macro h twice
]sh          # store this macro in h

[            # start "increment" macro (called when n=0, the operation beneath addition)
LaLnLb       # pop a, b, and n
F+sb         # replace the top value on b with b+15
q            # return
]si          # store this macro in i

[            # start "base case" macro (called when n>0 and b=0)
LbLnLa       # pop b, n, and a
sb           # replace the top value on b with a
q            # return
]sj          # store this macro in j

Fsa          # store F (15) in a
Fsb          # store F (15) in b
FFFFFFsn     # store FFFFFF "base 10" (150000+15000+1500+150+15=1666665) in n
lhx          # load and call macro h
lbp          # load and print b

언급 한 바와 같이, 이것은 곱셈과 그 이상의 기본 케이스가 더하기위한 기본 케이스로 대체된다는 점에서 하이퍼 오퍼레이션 기능에서 벗어난다. 이 코드는 것처럼 동작 a*0 = a^0 = a↑0 = a↑↑0 ... = a대신 수학적으로 올바른의, a*0 = 0및a^0 = a↑0 = a↑↑0 ... = 1 . 결과적으로 필요한 것보다 약간 높은 값을 계산하지만 더 큰 숫자를 목표로하기 때문에 큰 문제는 아닙니다. :)

편집 : 방금 증가하는 매크로에서 숫자가 실수로 코드에 삽입 된 것을 알았습니다 n=0. 각 증분 연산을 15 씩 스케일링하는 부작용이있는 'F'(15)로 대체하여 제거했습니다. 이것이 최종 결과에 얼마나 영향을 미치는지는 확실하지 않지만 아마도 지금은 훨씬 더 큽니다.

런타임에 더 이상 제한이 없습니까? 그래 그리고 나서.

최신 컴퓨터에서 프로그램을 실행할 수 있어야합니까?

64 비트 컴파일을 사용하는 두 솔루션은 모두 long64 비트 정수입니다.

C : 10 이상 ^{(2 64 - 1) (2) (64)} 자체보다 10 ^{10 355,393,490,465,494,856,447} ≈ 10 ↑↑ 4.11820744

long z;void f(long n){long i=z;while(--i){if(n)f(n+~z);printf("%lu",~z);}}main(){f(~z);}

88 자

이 수식을 더 쉽게 만들기 위해을 사용하겠습니다 t = 2^64-1 = 18446744073709551615.

mainf의 매개 변수로 호출 합니다.이 매개 변수는 시간 t을 반복 t하여 값을 인쇄 할 때마다 매개 변수로 t호출 합니다.ft-1

인쇄 된 총 자릿수 : 20 * t.

f매개 변수 를 사용하여 호출하는 각 호출 t-1은 t시간 을 반복 하고 값을 인쇄하고 t매개 변수를 사용하여 f를 호출 t-2합니다.

인쇄 된 총 자릿수 : 20 * (t + t*t)

나는 3 비트 정수의 동등 (I 설정하여이 프로그램을 시도 i = 8하고 주요 전화를했다 f(7)). 인쇄 문 6725600 번에 도달했습니다. 그에게 작동 7^8 + 7^7 + 7^6 + 7^5 + 7^4 + 7^3 + 7^2 + 7나는이 전체 프로그램에 대한 최종 카운트 믿고, 따라서 :

인쇄 된 총 자릿수 : 20 * (t + t*t + t^3 + ... + t^(t-1) + t^t + t^(2^64))

(2 ⁶⁴ -1) ^{2 64} 계산 방법을 잘 모르겠습니다 . 그 합은 (2 ⁶⁴ ) ^{2 64} 보다 작으며 ,이 계산을 수행하려면 2의 거듭 제곱이 필요합니다. 따라서 (2 ⁶⁴ ) ^{2 64 -1을} 계산합니다 . 실제 결과보다 작지만 2의 거듭 제곱이므로 다른 결과와 비교하기 위해 10의 거듭 제곱으로 변환 할 수 있습니다.

누구든지 그 합산을 수행하는 방법 또는 (2 ⁶⁴ -1) ^{2 64} 를 10 ⁿ 으로 변환하는 방법을 알고 있습니까 있습니까?

20 * 2 ^ 64 ^ (2 ^ 64-1)
20 * 2 ^ 64 ^ 18446744073709551615
20 * 2 ^ (64 * 18446744073709551615)
20 * 2 ^ 1180591620717411303360
10 * 2 ^ 1180591620717411303361
지수를 10의 거듭 제곱으로 나누려면 지수의 밑을 10의 거듭 제곱으로 바꿉니다.
1180591620717411303361 / 3.321928094887362347870319429489390175864831393024580612054756 = 
355393490465494856446
10 * 10 ^ 355393490465494856446
10 ^ 355393490465494856447

그러나 인쇄 된 자릿수입니다. 정수의 값은 10만큼 제곱하므로 10 ^ 10 ^ 355393490465494856447

이 프로그램의 스택 깊이는 2 ^ 64입니다. 루프 카운터를 저장하기 위해 2 ^ 72 바이트의 메모리입니다. 40 억 테라 바이트의 루프 카운터입니다. 2 ^ 64 레벨의 재귀에 대해 스택에 갈 다른 것들은 말할 것도 없습니다.

편집 : 오타 쌍을 수정하고 log2 (10)에 더 정확한 값을 사용했습니다.

편집 2 : 잠깐만, printf가 바깥에있는 루프가 있습니다. 고쳐 봅시다. 초기화가 추가되었습니다 i.

편집 3 : Dang it, 이전 편집에서 수학을 망쳤습니다. 결정된.

이것은 곧 완료되지는 않지만 최신 컴퓨터에서 실행될 것입니다.

C : 10 ^ 10 ^ 136 ≈ 10 ↑↑ 3.329100567

#define w(q) while(++q)
long a,b,c,d,e,f,g,x;main(){w(a)w(b)w(c)w(d)w(e)w(f)w(g)printf("%lu",~x);}

98 자

이것은 매 반복마다 한 번씩 0의 비트 역수 인 2 ^ 64-1을 인쇄합니다. 2 ^ 64-1은 20 자리 숫자입니다.

자릿수 = 20 * (2^64-1)^7= 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187500

프로그램 길이를 100 자로 반올림, 점수 = 인쇄 매수 / 1,000,000

점수 = 10 ^ 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187494

R- 49 41 문자 코드, 4.03624169270483442 * 10 ^ 5928 ≈ 10 ↑↑ 2.576681348

set.seed(T)
cat(abs(.Random.seed),sep="")

다음과 같이 인쇄됩니다.

403624169270483442010614603558397222347416148937479386587122217348........

ECMAScript 6-10 ^ 3 ↑↑↑↑↑ 3 / 884736

(3 ↑↑↑↑ 3은 G (1), 여기서 G (64)는 그레이엄 수))

u=-~[v=+[]+[]]+[];v+=e=v+v+v;D=x=>x.substr(u);K=(n,b)=>b[u]?n?K(D(n),K(n,D(b))):b+b+b:e;u+K(v,e)

출력 : 10 ^ 3 ↑↑↑↑↑ 3

힌트 :

GG (64)가 그레이엄 수인 함수입니다. 입력은 정수입니다. 출력은 0으로 작성된 단항 문자열입니다 . 간결성을 위해 제거되었습니다.

KKnuth 위쪽 화살표 함수 a ↑ ⁿ b (여기서 a는 암시적임) 입력은 n, 단항 문자열, b는 단항 문자열입니다. 출력은 단항 문자열입니다.

u "1"입니다.

v "0000"또는 G (0)

e "000"입니다.

씨

(대런 스톤에게 사과와 함께)

long n,o,p,q,r;main(){while(--n){while(--o){while(--p){while(--q){while(--r){putchar('z'-'A');}}}}}}

n = 2 ^ 64 자리 숫자 (9 ...)

l = 100 자

점수 e 1e + 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936570 ≈ 10 ↑↑ 3.2974890744

[점수 = n ^ 5 / l ^ 3 = (10 ^ (2 ^ 320) -1) / (100 ^ 3) = (10 ^ 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576-1) / (10 ^ 6)]

나는이 답변에 대해 무자비하게 쓸데없는 자격을 얻지 만 저항 할 수는 없었습니다. 나는 명백한 이유로 스택 교환에서 나처럼 행동하는 것을 권장하지 않습니다. :-피

편집 : 같은 일을하고 싶은 유혹에 저항하기가 더 어려울 것입니다

long n;main(){putchar('z'-'A');putchar('e');putchar('+');while(--n){putchar('z'-'A');}

...하지만 의도되었지만 지정되지 않은 규칙은 숫자를 구성하는 전체 자릿수를 인쇄해야한다고 가정합니다.

새로운 루비 : 점수 ~ F _{ω ^ω2 +1} (126 ² 2 ¹²⁶ )

여기서 f _α (n)은 빠르게 성장하는 계층입니다.

n=?~.ord;H=->a{b,*c=a;eval"b ?H[b==$.?c:[b==~$.?n:b-(b<=>$.)]*n+c]:p(n+=n);"*n};eval"H[~n];".*n*n<<n

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

는 *n단지 문자열과 배열 곱셈을, 그래서 그들은 잘해야한다.

Ungolfed 코드 :

n = 126
H =-> a {
    b, *c = a
    n.times{
        case b
        when nil
            puts(n += n)
        when 0
            H[c]
        when -1
            H[[n]*n+c]
        else
            H[[b.-b<=>0]*n+c]
        end
    }
}
(n*n<<n).times{H[~n]}

where 보다 가까운 b.-b<=>0정수를 반환합니다 .10b

설명:

n의 모든 호출이 시작될 때 인쇄합니다 H.

H[[]]복식 n( n배), 즉 n = n<<n.

H[[0,a,b,c,...,z]]전화 H[[a,b,c,...,z]]( n회).

H[[k+1,a,b,c,...,z]]통화 H[[k]*n+[a,b,c,...,z]]( n회), 여기서 [k]*n = [k,k,...,k].

H[[-1,a,b,c,...,z]]전화 H[[n]*n+[a,b,c,...,z]]( n회).

H[[-(k+1),a,b,c,...,z]]전화 H[[-k]*n+[a,b,c,...,z]]( n회).

H[k] = H[[k]].

내 프로그램이 초기화 된 n = 126다음 H[-n-1]126 ² 2 ¹²⁶ 번 호출 됩니다.

예 :

H[[0]]H[[]]적용되는 전화 n = n<<n( n시간).

H[[0,0]]H[[0]]( n번) 을 호출 합니다.

H[[1]]H[[0]*n]( n번) 을 호출 합니다.

H[[-1]]H[[n]*n]( n번) 을 호출 합니다.

H[[-1,-1]]H[[n]*n+[-1]]( n번) 을 호출 합니다.

H[[-3]]H[[-2]*n]( n번) 을 호출 합니다.

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

다른 멋진 것들에 대한 개정판 을 참조하십시오 .

Haskell-Ackermann 함수가 결과에 20 번-99 자 적용됨

이것은 ackermann 함수를 기반으로 얻을 수있는 가장 좋은 haskell 솔루션입니다 .nm의 솔루션과 비슷한 점을 알 수 있습니다 .i = round $ log pi는 거기에서 영감을 얻었으며 나머지는 우연입니다.

i=round$log pi
n?m|m<i=n+i|n<i=i?(m-i)|True=(n-i)?m?(m-i)
a n=n?n
b=a.a.a.a
main=print$b$b$b$b$b$i

ackermann 기능을 한 번에 시작하여 20 번 자체적으로 실행합니다.

• 1,
• 삼,
• 61,
• a (61,61),
• a (a (61,61), a (61,61)) --- 우리는 이것을 ₂ (61) 또는 ₄ (1) 이라고 부릅니다.
• ₃ (61)
• ...
• ₍₁₈₎ (61) 또는 ₍₂₀₎ (1). 나는 이것이 대략 g ₁₈ 이라고 생각합니다 (아래 참조).

wikipedia는 다음과 같이 말합니다.

a (m, n) = 2 ↑ ^m-2 (n + 3)-3

이것에서 우리는 a3 (1) = a (61,61) = 2 ↑ ⁵⁹ 64 + 3을 볼 수 있습니다. 이것은 시작시 3이 생각보다 훨씬 중요하지 않으면 g1 = 3 ↑ ⁴ 3 보다 분명히 큽니다 . 그 후, 각 레벨은 다음을 수행합니다 ( _n 의 중요하지 않은 상수는 버림 ).

• g _n = 3 ↑ ^{g _n-1} 3
• a _n ~ = 2 ↑ ^{a _n-1} (a _n-1 )

이것들이 대략 동등하면 ₂₀ (1) ~ = g ₁₈ 입니다. _n 의 최종 항 (a _n-1 )은 3보다 훨씬 크므로 잠재적으로 g ₁₈ 보다 큽니다 . 단일 반복으로도 향상시킬 수 있는지 다시보고 할 수 있는지 알아 보겠습니다.

x86 기계 코드-100 바이트 (MSDOS .com 파일로 조립 됨)

참고 : 규칙을 약간 구부릴 수 있습니다

이 프로그램은 2 ^{(65536 * 8 + 32) 구} 를 출력 하여 (10 ^{2 524320} -1) / 1000000에 점수를 넣습니다.

카운터로서이 프로그램은 전체 스택 (64kiB)과 2 개의 16 비트 레지스터를 사용합니다.

조립 된 코드 :

8A3E61018CD289166101892663018ED331E4BB3A01438A2627
018827A0300130E4FEC4FEC4FEC410E4FEC400E431C95139CC
75FB31D231C931DBCD3F4175F94275F45941750839D4740D59
4174F85131C939D475F9EBDD8B266301A161018ED0C3535858

어셈블리:

ORG 0x100

SECTION .TEXT
            mov bh, [b_ss]
            mov dx, ss
            mov [b_ss], dx
            mov [b_sp], sp
            mov ss, bx
            xor sp, sp
            mov bx, inthackdst
            inc bx
            mov ah, [inthacksrc]
            mov [bx], ah
            mov al, [nine]
            xor ah, ah
            inc ah
            inc ah
            inc ah
inthacksrc: adc ah, ah
            inc ah
            add ah, ah
            xor cx, cx
fillstack:  push cx
nine:       cmp sp, cx
            jnz fillstack
regloop:    xor dx, dx
dxloop:     xor cx, cx
cxloop:     xor bx, bx
inthackdst: int '?'
            inc cx
            jnz cxloop
            inc dx
            jnz dxloop
            pop cx
            inc cx
            jnz restack
popmore:    cmp sp, dx
            jz end
            pop cx
            inc cx
            jz popmore
restack:    push cx
            xor cx, cx
            cmp sp, dx
            jnz restack
            jmp regloop
end:        mov sp, [b_sp]
            mov ax, [b_ss]
            mov ss, ax
            ret

b_ss:       dw 'SX'
b_sp:       db 'X'

씨

파일 크기는 45 바이트입니다.

프로그램은 다음과 같습니다

main(){long d='~~~~~~~~';while(--d)printf("%ld",d);}

그리고 생성 된 수는 10 ^ (10 ^ (10 ^ 1.305451600608433))보다 큽니다.

내가 std로 리디렉션 한 파일은 현재 16Gb 이상이며 여전히 증가하고 있습니다.

컴퓨터가 좋으면 프로그램이 적당한 시간 안에 종료됩니다.

배정도 부동 소수점으로 내 점수를 계산할 수 없습니다.

GNU 배쉬, 10 ^ 40964096² / 80 ^ 3 ≈ 10 ↑↑ 2.072820169

C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C count=$C$C|tr \\$((C-C)) $SHLVL'

합리적인 시스템에서 C = 4096 SHLVL은 작은 양의 정수입니다 (보통 / bin / sh가 bash인지 여부에 따라 1 또는 2).

64 비트 UNIX 전용 :

점수 : ~ 10 ^ (40964096409640964096 * 40964096409640964096) / 88 ^ 3

C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C$C$C$C count=$C$C$C$C$C|tr \\$((C-C)) $SHLVL'

C, 10 ^ 10 ^ 2485766 ≈ 10 ↑↑ 3.805871804

unsigned a['~'<<'\v'],l='~'<<'\v',i,z;main(){while(*a<~z)for(i=l;printf("%u",~z),i--&&!++a[i];);}

부호없는 정수 258048의 배열을 만듭니다. 프로그램이 너무 길어 졌기 때문에 오랫동안 서명하지 못했습니다. 정의되지 않은 동작을 사용하고 싶지 않기 때문에 서명되지 않았습니다.이 코드는 적절한 C (main ()에서 반환되지 않음)이며 일반 컴퓨터에서 컴파일 및 실행되며 오랫동안 계속 실행됩니다. . 이 크기는 ASCII 이외의 문자를 사용하지 않고 합법적으로 표현할 수있는 최대 크기입니다.

마지막 요소부터 배열을 반복합니다. 우리는의 숫자를 인쇄하고 2^32-1, 요소를 증가시키고, 요소가 0으로 줄 바꿈되지 않으면 루프를 떨어 뜨립니다.(2^32 - 1)^254048 = 2^8257536 매번 10 자리를 인쇄하여 시간을 반복합니다.

보다 제한된 데이터 범위에서 원리를 보여주는 예제 코드는 다음과 같습니다.

#include <stdio.h>
unsigned int a[3],l=3,i,f;

int
main(int argc, char *argc){
        while (*a<4) {
        for (i = l; i-- && (a[i] = (a[i] + 1) % 5) == 0;);
            for (f = 0; f < l; f++)
                printf("%lu ", a[f]);
            printf("\n");
        }
}

결과는 약 10 ^ 10 ^ 2485766을 백만으로 나눈 값이며 여전히 약 10 ^ 10 ^ 2485766입니다.

Powershell (2.53e107976 / 72³ = 6.78e107970 ≈ 10 ↑↑ 1.701853371)

실행하는 데 5 초 이상이 걸립니다.

-join(-split(gci \ -r -EA:SilentlyContinue|select Length))-replace"[^\d]"

현재 드라이브에있는 모든 파일의 바이트 길이를 검색하고 연결합니다. 정규식은 숫자가 아닌 문자를 제거합니다.

파이썬 3, 점수 = ack (126,126) / 100 ^ 3

g=len('"');i=ord('~');f=lambda m,n:(f(m-g,f(m,n-g))if n else f(m-g,g))if m else n+g
print(f(i,i))

f 함수는 ackermann 함수이며, 호출하기에 충분한 공간이 있습니다.

편집 : 이전에 "else n + 1"은 Simply Beautiful Art에 대한 도전 규칙을 위반했습니다.

JavaScript 98 자

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(m.E<<k<<k<<k<<m.E);i+=j)a+=k;alert(a)

2.718e + 239622337 생성 ≈ 10 ↑↑ 2.9232195202

2.718e + 239622331보다 약간 높은 점수 인 경우 10 ↑↑ 2.9232195197

브라우저 충돌없이 만들 수있는 가장 큰 것입니다.

(console.log (a)는 전체 출력을 보여줍니다)

이것을 실행하지 마십시오 :

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(k<<k<<k<<k<<k<<k<<k);i+=j)a+=k;alert(a)

긴 답변과 비교하여 2.718 + e121333054704 ≈ 10 ↑↑ 3.0189898069 (일명 2.718 * 10 ^ (1.213 * 10 ^ 12)를 출력합니다.

브라우저를 충돌시키지 않으면 더 극단적 인 버전 : (80 문자)

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<k;i+=j)a+=k;alert(a)

e * 10 ^ (10 ^ 19) ≈ 10 ↑↑ 3.106786869689와 같은 크기의 숫자를 만듭니다.

편집 : 업데이트 된 코드 원래 솔루션 만 2.718e + 464 생성

파이썬 3:98 자, ≈ 10 ↑↑ 256

변수 인수 함수 사용 :

E=lambda n,*C:E(*([~-n][:n]+[int("%d%d"%(k,k))for k in C]))if C else n;print(E(*range(ord('~'))))

효과적으로, E는 첫 번째 인수를 감소시키면서 나머지 인수를 늘리지 만 인수에 -1을 넣는 대신 인수를 삭제한다는 점을 제외하고 나머지 인수는 증가시킵니다. 모든 사이클은 첫 번째 인수를 줄이거 나 인수 수를 줄이므로 종료됩니다. 증가하는 함수는 int ( "% d % d"% (k, k))이며, k ** 2 + 2 * k와 10 * k ** 2 + k 사이의 결과를 제공합니다. 내 코드는 * 기호를 사용하지만 곱셈으로 사용하지는 않습니다. 규칙의 명확한 요점은 기호 자체가 아닌 특정 작업을 제한하는 것이기 때문에 규칙을 따라야한다고 생각하는 가변적 인 수의 인수로 작업하는 데 사용됩니다.

E가 얼마나 빨리 커지는 지에 대한 몇 가지 예 :

E(1,1) = 1111
E(0,1,1) = E(11,11) = (approx) 10^8191
E(1,1,1) = E(1111,1111) = (approx) 10^(10^335)
E(2,1,1) = E(11111111,11111111) = (approx) 10^(10^3344779)

이 중 처음 두 개만 합리적인 시간 내에 내 컴퓨터에서 실행할 수 있습니다.

그런 다음 E가 호출됩니다 E(*range(ord('~'))).

E(0,1,2,3,4,5, ... ,121,122,123,124,125)

나는 이것이 얼마나 큰지 확실하지 않습니다 (나는 아무 소용이 없도록 근사하려고 노력했습니다). 그러나 그것이 정말로 ~ 크다는 것이 분명합니다.

예를 들어, 12 사이클에 대한 결과는 다음과 같습니다. (기술적으로는 조금 더)

E(2**27211,2**27211,2**27212,2**27212,2**27212,2**27212,2**27213,2**27213,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636)

결과 추정 :

증가하는 단계를 대략적으로 계산하면 lambda k: 10 * k**2함수를 다음과 같이 설명 할 수 있습니다.

E(n, C₁, C₂, ... Cᵥ) ≈ E(10^(n²/2) ⋅ C₁²ⁿ, 10^(n²/2) ⋅ C₂²ⁿ, ... 10^(n²/2) ⋅ Cᵥ²ⁿ)
                     ≈ E(10^((10^(n²/2) ⋅ C₁²ⁿ)²/2) ⋅ C₂^(2n  ⋅ 10^(n²/2) ⋅ C₁²ⁿ), ... )
                     ≈ E(10^((10^n² ⋅ C₁⁴ⁿ)/2) ⋅ C₂^(2n  ⋅ 10^(n²/2) ⋅ C₁²ⁿ), ... )

우리가 여기서하는 일은 10의 거듭 제곱을 쌓는 것입니다. 따라서 최종 점수는 대략 10 ↑↑ 256입니다.

더 나은 (부분적이지만) 결과 추정 :

이것은 10 * k**2다른 추정 과 동일 하게 사용합니다 .

E(0, b) = 10 * b**2
E(1, b) = 10 * (10 * b**2)**2 = 10 * 100 * b**4 = 10**3 * b**4
E(2, b) = 10 * (10**3 * b**4)**2 = 10 * (10**6 * b**8) = 10**7 * b**8
E(a, b) = 10**(2**(a+1)-1) * b**(2**(a+1))

이전 추정에 따르면 다음과 같습니다.

E(a, b) = 10**(a**2/a) * b**(2*a)

어느 것이 사용하기 때문에 실제 값보다 훨씬 작 a**2대신 2**a10 및 사용 a*2대신 2**aㄴ 대.

C (점수 ≈ 10 ^ 20 000 000 ≈ 10 ↑↑ 3.005558275)

• ~ 20GB 출력
• 41 자 (41 ^ 3은 아무 의미가 없음)

main(){for(;rand();printf("%d",rand()));}

rand()시드 함수가 없기 때문에 출력 에도 불구하고 결정적입니다.