진실에 직면 할 때가 왔습니다. 우리는 영원히 여기에 있지 않을 것입니다. 그러나 적어도 우리는 인류가 끝날 때까지 어려움을 겪더라도 인류를 오래 살릴 수있는 프로그램을 작성할 수 있습니다.

당신의 임무는 우주가 끝날 때까지 남은 시간보다 예상 실행 시간이 큰 프로그램을 작성하는 것입니다.

다음과 같이 가정 할 수 있습니다.

• 우주는 10 ¹⁰⁰⁰ 년 후에 엔트로피 로 죽을 것이다 .
• 너의 컴퓨터:
  • Unobtainium 으로 만들어 졌기 때문에 우주보다 오래 지속 됩니다.
  • 무한 메모리 / 스택 / 재귀 제한이 있습니다.
  • 프로세서 속도가 제한되어 있습니다.

프로그램이 종료 됨 (죄송하지만 무한 루프 없음)을 보여주고 예상 실행 시간을 계산해야합니다.

표준 허점이 적용됩니다.

이것은 코드 골프 도전이므로 기준을 만족하는 가장 짧은 코드가 이깁니다.

편집 :

불행하게도, Unobtainium의 불가피한 필드가 컴퓨터의 내부 시계를 방해하여 쓸모없는 것으로 밝혀졌습니다 (30 분 후). 따라서 시간 기반 프로그램은 즉시 중단됩니다. (어쨌든 살아있는 유산으로 기다리는 프로그램을 누가 떠나겠습니까?).

컴퓨터 프로세서는 Intel i7-4578U와 유사하므로 실행 시간을 측정하는 한 가지 방법은 더 작은 입력 (필요한)으로 비슷한 컴퓨터에서 프로그램을 실행하고 실행 시간을 추정하는 것입니다.

지휘대

#CharsLanguageUpvotes        Author        
1    5      CJam              20       Dennis                  
2    5      J                      5         algorithmshark      
3    7      GolfScript       30       Peter Taylor          
4    9     Python             39       xnor                      
5    10   Matlab             5         SchighSchagh      

_{* 31/08에 공감}

CJam, 5 바이트

0{)}h

작동 원리

 0   " Push 0.                                 ";
 {   "                                         ";
   ) " Increment the Big Integer on the stack. ";
 }h  " Repeat if the value is non-zero.        ";

힙이 더 이상 Big Integer를 저장할 수 없을 때이 프로그램은 중지되며, 이는 현대 데스크탑 컴퓨터에서 곧 발생하지 않습니다.

내 컴퓨터의 기본 힙 크기는 4,179,623,936 바이트입니다 (Fedora의 Java 8). 을 사용하여 임의의 값으로 늘릴 수 있으므로 -Xmx사용 가능한 주 메모리는 실제 제한뿐입니다.

죽음의 시간

인터프리터가 2 ^x 미만의 음이 아닌 큰 정수를 저장하기 위해 x 비트의 메모리가 필요하다고 가정하면 최대 2 ^{8 × 4,179,623,936} = 2 ^{33,436,991,488} 을 계산해야합니다 . 클럭 사이클 당 하나의 증분과 내 Core i7-3770 (터보가 장착 된 3.9 GHz)을 사용하면 2 ^{33,436,991,488} ÷ 3,400,000,000> 10 ^{10,065,537,393} 초가 ^걸리며 이는 10 ^{10,065,537,385} 년입니다.

자바 스크립트, 39

(function f(x){for(;x!=++x;)f(x+1)})(0)

설명

JavaScript는 큰 정수를 정확하게 나타내지 않기 때문에 루프 for(;x!=++x;)는 x적중 하면 종료됩니다 9007199254740992.

for 루프의 본문은 n 번째 피보나치 수인 Fib(9007199254740992) - 1시간 실행됩니다 Fib(n).

테스트를 통해 컴퓨터가 초당 150,000 회 미만의 반복 작업을 수행한다는 것을 알고 있습니다. 실제로 스택이 매우 커지기 때문에 훨씬 느리게 실행됩니다.

따라서 프로그램 (Fib(9007199254740992) - 1) / 150000을 실행하는 데 최소 몇 초가 걸립니다. Fib(9007199254740992)너무 커서 계산할 수 없었지만 10 ¹⁰⁰⁰ * 150,000 보다 훨씬 큽니다 .

편집 : 의견에서 언급했듯이 Fib(9007199254740992)대략 4.4092 * 10 ^{1882393317509686} 이며 실제로 충분히 큽니다.

파이썬 (9)

9**9**1e9

여기에는 10 ** 10000000 비트 이상이 있으므로 계산으로 인해 열사병이 훨씬 오래 걸리게됩니다.

나는 이것이 더 크지 만 여전히 합리적인 값을 얻기 위해 점점 더 많은 시간이 걸리는 것을 확인 했으므로 인터프리터에 의해 최적화되는 것이 아닙니다.

편집 : @ user2357112 덕분에 parens를 제거하여 두 문자로 골프를 쳤습니다. 파이썬이 연속 지수를 파워 타워로 취급하는 TIL.

GolfScript ( 12 7 자)

9,{\?}*

8 ^ 7 ^ 6 ^ 5 ^ 4 ^ 3 ^ 2 ~ = 10 ^ 10 ^ 10 ^ 10 ^ 183230을 계산하고 인쇄합니다. 10 ^ 1000 년 ~ = 10 ^ 1007.5 초 내에 인쇄 (계산은 신경 쓰지 않음)하려면 초당 약 10 ^ (10 ^ 10 ^ 10 ^ 183230-10 ^ 3) 자릿수를 인쇄해야합니다.

놀라운 68 66 바이트

}0
--@2
@2/\=0MB
}0@1\/
&0/\>0!!
--
@1
00@0
--/\=0
\\@0&0

Marbelous는 Rube Goldberg와 같은 기계에서 구슬로만 표현되는 값을 가진 8 비트 언어이므로 매우 쉽지 않았습니다. 이 접근 방식은 다음 의사 코드와 거의 같습니다.

function recursiveFunction(int i)
{
    for(int j = i*512; j > 0; j--)
    {
        recursiveFunction(i - 1);
    }
}

최대 값은 256이므로 (다른 위치에서 다르게 처리되는 Marbleous 프로그램에서 0으로 표시됨) recursiveFunction (1)은 총계가 256!*512^256약 10^1200, 즉 우주보다 오래 지속될 정도로 충분히 호출됩니다 .

Marbelous는 매우 빠른 인터프리터를 가지고 있지 않으므로 10^11매년이 함수의 호출에 대해 실행할 수있는 것처럼 보입니다. 즉, 우리는 10^1189수년 의 런타임을보고 있습니다.

Marbelous 보드에 대한 추가 설명

00@0
--/\=0
\\@0&0

0016 진수 (0)로 표시되는 언어 리터럴 (또는 대리석)입니다. 이 구슬은으로 떨어지며 --구슬은 1 씩 줄어 듭니다 (00은 줄 바꿈하여 소수점 이하 FF 또는 255로 바)). 값이 FF 인 Marble은 아래로 내려가 \\오른쪽으로 한 열을 아래로 밉니다 @0. 이것은 포털이며 구슬을 다른 @0장치 로 순간 이동시킵니다 . /\복사기는 장치 에 대리석이 있으며, 대리석의 사본 하나 --를 왼쪽에 배치합니다 (이 대리석은 포털 사이에서 계속 반복되고 모든 루프에서 감소합니다) =0.=0구슬을 값 0과 비교하고 구슬이 같으면 구슬이 떨어지도록하고 그렇지 않으면 오른쪽으로 밉니다. 구슬의 값이 0이면, &0동기화 장치 에 착륙합니다 . 나중에 자세히 설명하겠습니다.

결국, 이것은 루프에서 0 값 구슬로 시작하여 다시 0에 도달 할 때까지 감소시킨 다음 0 값 구슬을 동기화 프로그램에 넣고 동시에 반복합니다.

}0@1
&0/\>0!!
--
@1

}0입력 장치이며, 처음에는 프로그램을 호출 할 때 n 번째 (기본 0) 명령 줄 입력이 모든 }n장치에 배치됩니다 . 따라서 명령 행 입력 2로이 프로그램을 호출하면 02 값 대리석이 이것을 대체합니다 }0. 그런 다음이 구슬은 &0다른 동기화 장치 인 다른 싱크로 나이저 로 떨어지며 다른 &n모든 해당 항목 &n이 제출 될 때까지 구슬을 고정 시킵니다. 그런 다음 이전에 설명한 루프에서와 같이 대리석이 감소, 순간 이동 및 복제됩니다. 그런 다음 올바른 사본은 0이 아닌 >0경우 0 ( )으로 부등식을 검사합니다 . 0이면 오른쪽으로 밀리고에 착륙 !!하여 보드를 종료합니다.

자, 지금까지 우리는 255에서 0까지 지속적으로 카운트 다운하는 루프를 가지고 있으며 0에 도달 할 때마다 다른 유사한 루프 (명령 행 입력으로 공급)가 한 번만 실행되도록합니다.이 두 번째 루프가 n 번 실행되면 (최대 256) ) 프로그램이 종료됩니다. 루프의 최대 65536 런입니다. 우주보다 오래 살기에는 충분하지 않습니다.

}0
--@2
@2/\=0MB

이것은 친숙해 보이기 시작하고 입력이 한 번 감소한 다음이 값이 반복되어 복사됩니다 (대리석이 모든 루프 실행이 아니라 한 번만 감소됨). 그런 다음 0과 같고 0이 아닌지 확인합니다 MB. 이것은 Marbelous의 함수이며, 모든 파일은 여러 개의 보드를 포함 할 수 있으며 각 보드는 함수 :[name]입니다. 파일의 첫 번째 기능 (표준 이름 : MB)을 제외한 모든 기능. 따라서이 루프 n - 1는 n이 함수의이 인스턴스가 호출 된 값의 값으로 메인 보드를 계속 호출합니다 .

왜 n*512?

첫 번째 루프는 4 틱 (256 회)으로 실행되고 두 번째 루프는 보드가 종료되기 전에 n 번 실행됩니다. 이것은 보드가 n*4*256진드기 에 대해 작동한다는 것을 의미합니다 . 마지막 루프 (재귀 함수 호출)는 더 작고 2 틱으로 실행되므로 함수 n*4*256/2 = n*512시간 을 호출 할 수 있습니다 .

언급하지 않은 기호는 무엇입니까?

\/ 쓰레기통은 보드에서 대리석을 제거합니다. 이렇게하면 분리 된 대리석이 둥글게 반복되는 다른 대리석을 방해하지 않고 프로그램이 종료되지 않습니다.

보너스

놀라운 보드의 바닥에서 떨어지는 대리석이 STDOUT으로 출력되기 때문에이 프로그램은 실행되는 동안 많은 ASCII 문자를 인쇄합니다.

펄, 66 58 자

sub A{($m,$n)=@_;$m?A($m-1,$n?A($m,$n-1):1):$n+1;}A(9,9);

위는 Ackermann-Péter 기능 의 구현입니다 . 나는 A (9,9)가 얼마나 큰지 알지 못하지만 평가하는데 엄청나게 오랜 시간이 걸릴 것이라고 확신합니다.

MATLAB, 58 52 자

적어도 하나의 유한 정밀도 산술 솔루션이 필요합니다.

y=ones(1,999);while y*y',y=mod(y+1,primes(7910));end

x = ones (1,999); y = x; 임의의 (y), y = mod (y + x, 프라임 (7910)); 끝

( 6 문자를 노크 해준 @DennisJaheruddin 덕분에 )

완료하는 데 필요한주기 수는 처음 999 소수의 곱으로 제공됩니다. 이들 중 대다수가 10을 훨씬 넘기 때문에 수렴을 실현하는 데 필요한 시간은 최소 시간 제한보다 수백 또는 수천 배 더 커집니다.

수학, 25 19 바이트

이 솔루션은 기능이 실격되기 전에 게시되었습니다.

While[TimeUsed[]<10^10^5]

TimeUsed[]세션이 시작된 이후 초를 반환하고 Mathematica는 임의 정밀도 유형을 사용합니다. 1 년에 약 10 ⁷ 초가 있으므로 ^1010000 초를 기다리는 것으로 충분합니다.

더 짧고 / 간단한 (/ 유효한) 대안 :

For[i=0,++i<9^9^9,]

대신 세어 보자. 우리는 1 초에 상당히 많은 증분을 할 수 있기 때문에 조금 더 세어야 할 것이지만, 더 높은 한계는 실제로 문자 비용이 들지 않습니다.

기술적으로 두 솔루션 모두 문제가 최소 프로세서 속도를 지정하지 않기 때문에 훨씬 낮은 한계를 사용할 수 있습니다.

파이썬 3-49

이것은 유용한 것입니다 : Gregory-Leibniz 무한 시리즈를 사용하여 Pi를 전례없는 정확도로 계산합니다.

궁금한 점이있을 경우이 프로그램은 10**10**10**2.004302604952323시간을 반복합니다.

sum([4/(i*2+1)*-1**i for i in range(1e99**1e99)])

임의 정밀도 : 78

from decimal import*
sum([Decimal(4/(i*2+1)*-1**i)for i in range(1e99**1e99)])

이미지 소스

말기 호흡

엄청난 계산이 이루어지기 때문에 1e99**1e99반복 작업은 몇 1e99**1e99년 안에 완료됩니다. 이제 (1e99**1e99)-1e1000거의 차이가 없습니다. 그것은이 프로그램이 우주의 죽음보다 훨씬 더 오래 실행될 것이라는 것을 의미합니다.

갱생

이제 과학자들은 10**10**56 years양자 변동이나 터널링으로 인해 우주가 다시 태어날 것이라고 제안합니다 . 각 우주가 정확히 같은 경우 내 프로그램이 몇 개의 우주를 통과 할 수 있습니까?

(1e99**1e99)/(1e10+1e1000+10**10**56)=1e9701

우주가 항상 1e10+1e1000몇 년을 살다가 10**10**56'재부팅'하는 데 몇 년이 걸린다고 가정하면 내 프로그램은 1e9701우주를 통해 살 것 입니다. 물론 이것은 unobtainium이 Big Bang을 통해 살 수 있다고 가정합니다.

파이썬 59 (대부분 작동)

나는 저항 할 수 없었다

from random import*
while sum(random()for i in range(99)):0

이것이 밀리 초 이내에 이론적으로 종료 될 수 있다는 것이 사실이지만, 평균 런타임은 10^400우주의 지정된 수명 보다 몇 배나 길다. @BetaDecay, @undergroundmonorail 및 @DaboRoss 덕분에 17 자 정도 줄였습니다.

J-5 자 정도

숫자 9는 항상 그 x옆 에 약간 있기 때문에 다음의 모든 것은 임의의 정밀 산술 입니다.

에서 일곱 자, 우리가 !^:!!9x, 좀 실행 같은 인

n = 9!
for i in range(n!):
    n = n!

임의의 정밀한 산술. Synthetica가 그렇게 말했기 때문에 이것은 한도를 확실히 초과하므로 상한이 있습니다.

에서 여섯 개 문자, 우리는 또한 쓸 수있는 ^/i.9x모든 중간 결과를 계산하는, 0 ^ 1 ^ 2 ^ 3 ^ 4 ^ 5 ^ 6 ^ 7 ^ 8. Wolfram | Alpha 2^3^4^5^6^7^8는 대략 이라고 말하며 10 ^ 10 ^ 10 ^ 10 ^ 10 ^ 10 ^ 6.65185, 이는 아마도 검사를 취소합니다.

우리는 또한 다섯 문자 !!!9x를 가지고 있는데, 이것은 단지 ((9!)!)!입니다. W | A는 그것이 10 ^ 10 ^ 10 ^ 6.2695여전히 충분히 커야한다고 말합니다. 그것은 우주에서 나노초의 수 1.6097e1859933보다 확실히 큰 -ish 숫자 3.154e1016와 같지만 어떻게 알아낼 지 모르겠습니다. 이러한 것들의 실제 런타임.

그러나 인쇄만으로도 우주보다 오래 지속될 수 있으므로 괜찮을 것입니다.

C, 63 56 자

f(x,y){return x?f(x-1,y?f(x,y-1):1):y+1;}main(){f(9,9);}

이것은 Wilhelm이라는 사람의 아이디어를 기반으로합니다. 내 유일한 기여는 코드를이 짧고 읽을 수없는 부분으로 압축하는 것입니다.

그것이 종료한다는 것을 증명하는 것은 유도에 의해 이루어진다.

• x가 0이면 즉시 종료됩니다.
• x-1 및 모든 y에 대해 종료되면 x에 대해서도 종료되며 이는 자체적으로 유도로 표시 될 수 있습니다.

유도에 의한 유도 단계 증명 :

• y가 0이면 x-1의 재귀 호출이 하나 뿐이며, 이는 유도 가정에 의해 종료됩니다.
• f (x, y-1)이 종료되면 f의 가장 안쪽 호출이 정확히 f (x, y-1)이고 가장 바깥 쪽 호출이 유도 가설에 따라 종료되므로 f (x, y)도 종료됩니다.

예상 실행 시간은 A (9,9) / 11837 초입니다. 이 숫자는 관측 가능한 우주의 쿼크 수보다 많은 자릿수를 갖습니다.

MATLAB ( 10 8 자)

1:9e1016

IMHO, 대부분의 항목은 크고 복잡한 것을 계산하여 너무 열심히 노력하고 있습니다. 이 코드는 단순히 1x 부터 9x10 ¹⁰¹⁶ double 의 배열을 초기화하며 , 7.2x10 ^ ¹⁰¹⁷ 바이트가 필요합니다. 최대 메모리 대역폭을 가진 최신 CPU에서 21GB / s 또는 6.63x10 ^ ¹⁷ 바이트 / 년인 에서는 어레이를 초기화 하는데도 최소 1.09x10 ¹⁰⁰⁰ 년 이 소요 됩니다. 후행 세미콜론으로 출력을 억제합니다. (;

오래된 솔루션

nan(3e508)

대안 적으로

inf(3e508)

이 코드는 단순히 NaN 크기 3e508x 3e508 = 9e10168 바이트 더블 또는 7.2e1017바이트 s / infinities의 .

펄, 16 자

/$_^/for'.*'x1e9

이것은 ". *"를 10 억 번 반복하는 문자열을 만든 다음 정규식 일치에서 바늘과 건초 더미로 사용합니다. 결과적으로 정규식 엔진은 문자열의 가능한 모든 파티션을 20 억 자 길이로 시도합니다. Wikipedia의이 공식 에 따르면 약 ^{10,2182 개의} 파티션이 있습니다.

위의 솔루션은 16 자 길이이지만 약 2Gb의 메모리 만 필요하므로 실제 컴퓨터에서 실행할 수 있습니다. 무한 메모리와 유한 레지스터 크기 (어쩌면 의미가 없을 수도 있음)를 가정하면 런타임을 크게 늘리면서 15자를 줄일 수 있습니다.

/$_^/for'.*'x~0

(나는 그것을 테스트하지는 않았지만 적어도 6Gb의 RAM을 가진 64 비트 컴퓨터에서 빌드 된 32 비트 Perl에서 작동 할 수 있다고 생각합니다.)

노트:

• x 문자열 반복 연산자입니다.
• 그만큼 for 실제 루프 아니다; 하나의 문자를 저장하는 데만 사용됩니다 (와 비교 $_=".*"x1e9;/$_^/).
• 마지막 ^정규 표현식 은 빈 문자열 만 일치하도록합니다. 정규 표현식 수량자는 기본적으로 탐욕 스럽기 때문에 엔진이 마지막으로 시도하는 것입니다.
• 내 컴퓨터의 값 (1..13)에 대한 벤치 마크는 실행 시간이 실제로 O (exp (n))이며 Wikipedia 수식의 O (exp (sqrt (n)))보다 훨씬 큽니다.

J (12)

(!^:(!!9))9x

이것이 파이썬에서 오는 것 ( !작동 한다고 가정 ) :

a = 9 
for i in range((9!)!):
    a = a!

편집하다:

글쎄, 프로그램은 최대한 걸릴 수 있습니다. 2 × 10^-1858926 필요한 시간 내에 완료하는 데 최대 사이클 당 몇 초가 . 팁 : 이것은 첫 번째 사이클에서도 작동하지 않으므로 마지막 사이클은 신경 쓰지 마십시오.

또한이 프로그램은 우주에 엔트로피보다 많은 메모리가 필요할 수 있습니다 ...

C # 217

나는 골퍼가 아니지만 Ackerman의 기능에 저항 할 수 없었습니다 . 또한 런타임을 계산하는 방법을 모르지만 확실히 중단 되며이 버전 보다 확실히 더 오래 실행됩니다 .

class P{
static void Main(){for(int i=0;i<100;i++){for(int j=0;j<100;j++){Console.WriteLine(ack(i,j));}}}
static int ack(int m,int n){if (m==0) return n+1;if (n ==0) return ack(m-1,1);return ack(m-1,ack(m,n-1));}
}

코드 골프를 먼저 시도하지만 여기에 간다.

VBA- 57 45

x=0
do
if rnd()*rnd()<>0 then x=0
x=x+1
while 1=1

따라서 1 in 2 ^ 128 이벤트가 발생하면 X가 1 씩 증가하고 발생하지 않으면 재설정됩니다. 이 이벤트는 2 ^ 64 + 1 회 연속으로 발생하면 코드가 종료됩니다. 시간 계산을 시작하는 방법을 모르지만 시간이 거대하다고 생각합니다.

편집 : 수학을 연습했고 각 루프에서 발생할 확률은 2 ^ 128 ^ (1 + 2 ^ 64)에서 1이며 길이는 약 20000 자릿수입니다. 연간 10 * 1000 년주기가 3 * 10 ^ 13 사이클 인 1000000 루프 / 초 (얇은 공기 수에서 야구장)와 30000000 초 / 년을 가정하면 10 * 1000 년 남은 시간은 3 * 10 ^ 1013주기이므로 이는 약 20 배 지속될 것입니다. 우주에 남은 시간. 수학이 직관을 뒷받침하는 것이 기쁘다.

C, 30 자

main(i){++i&&main(i)+main(i);}

2의 칭찬 부호가있는 오버플로 및 32 비트 정수를 가정하면, 이것은 약 2 ^{2 32 개의} 함수 호출 에 대해 실행 되며, 우주가 끝나는 데 충분한 시간이 필요합니다.

GolfScript, 13 자

0{).`,9.?<}do

이 프로그램은 0에서 10 ^{9 9 −1} = 10 ^{387420488까지만 계산} 합니다. 낙관적으로 컴퓨터가 100GHz에서 실행되고 단일 주기로 프로그램의 각 반복을 실행할 수 있다고 가정하면 프로그램은 10 ^{9 9 -12} 초 또는 약 3 × 10 ^{9 9 -20} = 3 × 10 ^{387420469로 실행됩니다.} 연령.

프로그램을 테스트하려면를 대체 할 수 9로모그래퍼 2은 10에서 정지 할 것이다, ^{2 2 -1} = 10 ³ 사용 (= 1000 3대신의가 2가 10에서 정지 할 것 ^{3 3 -1} = 10 ⁽²⁶⁾ , 한 위의 낙관적 인 가정에도 불구하고 적어도 몇 백만 년 동안 도달하지 못할 것입니다.)

오토 핫키 37

loop {
if (x+=1)>10^100000000
break
}

하스켈, 23

main=interact$take$2^30

이 프로그램은에서 1073741824자를 읽은 후 종료됩니다 stdin. 에 데이터를 파이핑하지 않고 실행하는 경우 stdin키보드에이 수의 문자를 입력해야합니다. 키보드에 105 개의 키가 있고 각각 100k 기계 사이클에 대해 등급이 지정되어 있고 비 데드 키 스트로크를 생성하도록 프로그래밍되어 있고 자동 반복이 해제되어 있고 키보드 소켓이 100 회 연결주기를 허용한다고 가정하면 컴퓨터 가동 시간당 최대 키 스트로크 수는 1050000000입니다. 프로그램을 종료하기에 충분하지 않습니다.

따라서 프로그램은 더 많은 하드웨어가주기 수 측면에서 사용 가능한 경우에만 종료되며,이 실행중인 유니버스에는 사실상 적용되지 않습니다. 다음에 품질이 수량보다 우선 순위가 높은 경우가 있습니다. 그때까지이 프로그램은 원칙적으로 종료되지만 실제로는 종료되지 않습니다.

~ ATH, 56

에서 가상의 언어 ~ ATH :

import universe U;
~ATH(U) {
} EXECUTE(NULL);
THIS.DIE()

~ ATH는 다루기 어려운 언어입니다. 그것의 논리는 무한 루프, 또는 효과적으로 상호 구성 가능한 구조의 루프로 구성됩니다.

많은 ~ ATH 코더가하는 일은 유한 구문을 가져 와서 루프를 수명에 바인딩하는 것입니다. 예를 들어 여기의 주요 고리는 U라고 표시된 우주의 죽음에 따라 종료됩니다. 그렇게하면 영원히 대신 수십억 년을 기다려야합니다.

경계 허점 위반에 대해 사과드립니다. 나는 그것이 지나치기에는 너무 관련이 있다고 생각했다.

누군가가 실제로 이것으로 즐겁게했다면, 자세한 내용은 (1) , (2) , (3) , (4)

루비 (34)

줄 ([0]*9).permutation.each{print}은 9 시간 동안 약 2.47 초가 걸립니다! 라인 ([0]*10).permutation.each{print}이 10 분 동안 약 24.7 초 걸립니다. 인쇄, 그래서 나는 여기에 외삽하고 (24.7/10!)*470! seconds in years어느 것이 6.87 * 10 ^ 1040인지 계산할 수 있다고 생각 합니다.

([0]*470).permutation.each{print}

자바 스크립트 68 62 자

(function a(m,n){return m==0?n+1:a(m-1,n==0?1:a(m,n-1))})(5,1)

이것은 다음과 같이 쓰여질 수있는 Ackermann 함수 를 사용합니다

function ackermann(a, b) {
  if (a == 0) return b + 1;
  if (b == 0) return ackermann(a-1, 1);
  else return ackermann(a-1, ackermann(a, b-1));
}

런타임 시간이 기하 급수적으로 증가하므로 계산하는 데 시간이 오래 걸립니다. 이 영어가 아닌 경우에도 여기에 당신의 반환 값의 개요를 얻을 수 있습니다. 표에 따르면 ackermann(5,1)같다 2↑↑(65533)-3당신이 매우 큰, 알고,이다.

Befunge '93 -40 바이트

(20x2 프로그램)

v<<<<<<<<<<<<<<<<<<<
>??????????????????@

이 프로그램은 난수를 사용하여 지연시킵니다. Befunge 통역사는 상당히 느리기 때문에이 프로그램은 법안에 맞아야합니다. 그렇지 않은 경우 항상 수평으로 확장 할 수 있습니다. 이 프로그램의 예상 실행 시간을 계산하는 방법을 정확히 모르지만 각각을 알고 있습니까? 50/50의 확률로 시작하거나 가로 위치를 1 씩 변경할 수 있습니다. 구글 계산기가 "무한대"라고 말하는 (18 ^ 2)!

편집 : 나는 다른 Befunge 답변을 보지 못했습니다. 이것은 내 첫 번째 게시물입니다. 죄송합니다.

APL, 10

나는 이것이 올바른 결정이라고 생각하지 않지만 (결정적이지 않기 때문에) 어쨌든 ......

{?⍨1e9}⍣≡1

이 프로그램은 1e9 숫자의 임의 순열을 계산하고 ( ?⍨1e9) 두 개의 연속 출력이 같을 때까지 반복합니다 ( ⍣≡)

따라서 순열을 계산할 때마다 1000000000의 1을 갖습니다! 종료 가능성. 그리고 1000000000! 는 10 ^{10 8} 이상 이다.

순열을 계산하는 데 걸리는 시간은 1000000000!으로 무의미합니다. 그러나 일부 테스트는 이것이O(n) 이며 외삽은 약 30 초를 제공합니다.

그러나 통역사는 2 ³¹ -1 보다 큰 임의 함수에 대한 입력을 거부 하므로 (1e9를 사용함) 1000000000 숫자의 순열을 생성하면 작업 공간에 전체 오류가 발생했습니다. 그러나 개념적으로 무한 메모리를 갖춘 이상적인 APL 인터프리터로 수행 할 수 있습니다.

따라서 64 비트 아키텍처를 가정 할 때 1e9 대신 2 ⁶³ -1 을 사용 하여 실행 시간을 10 ^{10 20} 이상까지 높일 수 있습니다.

그러나 아키텍처가 이상적인 인터프리터와 관련이 있습니까? 지옥 시간이 아니므로 달리기 시간에 실제로 상한이 없습니다!

R, 45 바이트

(f=function(x)if(x)f(x-1)+f(x-1)else 0)(9999)

그것은 오래된 스레드이지만 R 답변이 없으며 우리는 그것을 가질 수 없습니다!

x가 20 일 때 런타임은 약 1 초였으며 2 ^ 9979 초의 런타임을 제안했습니다.

0을 1로 바꾸면 출력은 2 ^ x가되지만 x가 무엇이든지 출력은 0이됩니다 (오버플로 문제 방지).

자바 스크립트, 120 바이트

a=[0];while(a.length<1e4)(function(){var b=0;while(b<a.length){a[b]=(a[b]+1)%9;if(a[b])return;b++}a.push(1)})();alert(a)

최소 메모리 (아마도 0.5MB 미만)로 수행 할 수 있지만 약 10 ^8,750 이 소요됩니다. 년 .

little endian base-9 BigInteger가 9 ^{10 4 -1에} 도달 할 때까지 반복적으로 증가시킵니다 .

파이썬 3, 191 바이트

from random import*
r=randint
f=lambda n:2if n<2else f(n-1)
x=9E999
s=x**x
for i in range(f(x)**f(s)):
 while exec(("r(0,f(x**i))+"*int(f(x)))+"r(0,f(x**i))")!=0:
  s=f(x**s)
  print(s)

첫째, f는 재귀 적 계승 함수이며 매우 느립니다. 그런 다음 9 * 10⁹⁹⁹ 자체가있어 오버플로 오류가 발생하지만이 Unobtanium 컴퓨터에서는 발생하지 않습니다. For-Loop는 9E999를 반복합니다! ^ (9E999 ^ 9E999)! 시간은 9E999! + 0과 9E99 * ^ i 사이의 임의의 정수 인 경우 다음 반복에만 진행됩니다! 는 모두 0이며 while 루프의 모든 반복에서 (9E999 ^ s)!로 설정됩니다. 어, S의 인쇄 muuuuccchhhh 시간이 걸립니다 ... 잊고
나는 짧은 soloution하지 알고,하지만 난 정말 효과적인 것 같아요. 실행 시간 계산을 도와 줄 수 있습니까?

튜링 머신 그러나 방법이 더 나쁘다 , 167 바이트

0 0 1 1 2 0 0
1 0 1 0 4 0 0
0 1 1 1 2 0 0
1 1 1 1 5 0 0
0 2 1 0 3 0 0
1 2 0 1 1 0 0
0 3 1 1 4 0 0
1 3 0 0 2 0 0
0 4 1 0 0 0 0
1 4 0 1 3 0 0
0 5 1 0 6 0 1
1 5 1 1 2 0 0

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

Wikipedia 페이지 에서 6- 상태 2- 기호 Busy Beaver를 실행해야합니다 .

$7.412 \times 10^{36534}$