Đã đến lúc phải đối mặt với sự thật: Chúng ta sẽ không ở đây mãi mãi, nhưng ít nhất chúng ta có thể viết một chương trình sẽ tồn tại lâu hơn loài người ngay cả khi nó phải vật lộn đến cuối thời gian.

Nhiệm vụ của bạn là viết một chương trình có thời gian chạy dự kiến ​​lớn hơn thời gian còn lại cho đến khi vũ trụ kết thúc.

Bạn có thể cho rằng:

• Vũ trụ sẽ chết vì entropy sau 10 ¹⁰⁰⁰ năm nữa.
• Máy tính của bạn:
  • Sẽ tồn tại lâu hơn vũ trụ, bởi vì nó được làm từ Unobtainium .
  • Có giới hạn bộ nhớ / ngăn xếp / đệ quy vô hạn.
  • Bộ xử lý của nó có tốc độ hạn chế.

Bạn phải chỉ ra rằng chương trình của bạn chấm dứt (xin lỗi, không có vòng lặp vô hạn) và tính thời gian chạy dự kiến ​​của nó.

Các sơ hở tiêu chuẩn áp dụng.

Đây là một thử thách golf mã, vì vậy mã ngắn nhất đáp ứng các tiêu chí chiến thắng.

CHỈNH SỬA :

Thật không may, người ta đã phát hiện ra (30 phút sau) rằng trường không khả thi của Unobtainium can thiệp vào đồng hồ bên trong của máy tính, khiến nó trở nên vô dụng. Vì vậy, chương trình dựa trên thời gian dừng lại ngay lập tức. (Ai sẽ rời khỏi một chương trình chỉ chờ đợi như di sản sống của nó, dù sao?).

Bộ xử lý máy tính tương tự như Intel i7-4578U, vì vậy một cách để đo thời gian chạy là chạy chương trình của bạn trong một máy tính tương tự với đầu vào nhỏ hơn (tôi hy vọng) và ngoại suy thời gian chạy của nó.

Bục giảng

#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      

_{* Nâng cấp vào ngày 31/08}

CJam, 5 byte

0{)}h

Làm thế nào nó hoạt động

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

Chương trình này sẽ tạm dừng khi heap không thể lưu trữ Số nguyên lớn nữa, điều này sẽ không xảy ra sớm trên máy tính để bàn hiện đại.

Kích thước heap mặc định là 4.179.623.936 byte trên máy tính của tôi (Java 8 trên Fedora). Nó có thể được tăng lên một giá trị tùy ý với -Xmx, vì vậy giới hạn thực duy nhất là bộ nhớ chính khả dụng.

Thời gian của cái chết

Giả sử rằng trình thông dịch cần x bit bộ nhớ để lưu trữ Số nguyên lớn không âm dưới 2 ^x , chúng ta phải đếm tới 2 ^{8 × 4,179,623,936} = 2 ^{33,436,991,488} . Với một mức tăng trên mỗi chu kỳ xung nhịp và Core i7-3770 của tôi (3,9 GHz với turbo), việc này sẽ mất 2 ^{33.436,991,488} ÷ ^{3,400.000.000} > 10 ^{10.065.537.393} giây, tức là hơn 10 ^{10.065.537.385} năm.

JavaScript, 39

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

Giải trình

Vì JavaScript không thể hiện chính xác các số nguyên lớn, vòng lặp for(;x!=++x;)chấm dứt một lần xtruy cập 9007199254740992.

Phần thân của vòng lặp for sẽ được thực hiện Fib(9007199254740992) - 1lần, trong đó Fib(n)là số thứ n.

Từ thử nghiệm, tôi biết máy tính của tôi sẽ thực hiện dưới 150.000 lần lặp mỗi giây. Trong thực tế, nó sẽ chạy chậm hơn nhiều vì ngăn xếp sẽ phát triển rất lớn.

Do đó, chương trình sẽ mất ít nhất (Fib(9007199254740992) - 1) / 150000vài giây để chạy. Tôi chưa thể tính toán Fib(9007199254740992)vì nó quá lớn, nhưng tôi biết rằng nó lớn hơn 10 ¹⁰⁰⁰ * 150.000.

EDIT: Như đã lưu ý trong các ý kiến, Fib(9007199254740992)là khoảng 4,4092 * 10 ^{1882393317509686} , thực sự đủ lớn.

Con trăn (9)

9**9**1e9

Cái này có hơn 10 ** 10000000 bit, do đó, tính toán nó sẽ đưa chúng ta vượt qua cái chết nhiệt.

Tôi đã kiểm tra rằng việc này ngày càng mất nhiều thời gian hơn cho các giá trị lớn hơn nhưng vẫn hợp lý, vì vậy nó không chỉ được tối ưu hóa bởi trình thông dịch.

Chỉnh sửa: Đánh gôn hai ký tự bằng cách xóa parens nhờ @ user2357112. TIL rằng Python coi các số mũ liên tiếp như một tháp năng lượng.

GolfScript ( 12 7 ký tự)

9,{\?}*

Điều này sẽ tính toán và in 8 ^ 7 ^ 6 ^ 5 ^ 4 ^ 3 ^ 2 ~ = 10 ^ 10 ^ 10 ^ 10 ^ 183230. Để in nó (không bao giờ bận tâm đến tính toán) trong 10 ^ 1000 năm ~ = 10 ^ 1007,5 giây, nó cần in khoảng 10 ^ (10 ^ 10 ^ 10 ^ 183230 - 10 ^ 3) chữ số mỗi giây.

Không thể tin được 68 66 byte

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

Marbelous là một ngôn ngữ 8 bit với các giá trị chỉ được biểu thị bằng các viên bi trong một cỗ máy giống Rube Goldberg, vì vậy điều này không dễ dàng gì. Cách tiếp cận này gần tương đương với mã giả sau:

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

vì giá trị tối đa là 256, (được biểu thị bằng 0 trong chương trình Đá hoa cương, được xử lý khác nhau ở các vị trí khác nhau) Hàm đệ quy (1) sẽ được gọi là tổng cộng 256!*512^256bằng 10^1200, dễ dàng vượt qua vũ trụ.

Marbelous không có trình thông dịch rất nhanh, có vẻ như nó có thể chạy 10^11các cuộc gọi của chức năng này mỗi năm, điều đó có nghĩa là chúng ta đang xem xét thời gian chạy 10^1189nhiều năm.

Giải thích thêm về hội đồng quản trị

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

00là một ngôn ngữ theo nghĩa đen (hoặc một viên bi), được biểu thị dưới dạng thập lục phân (nên 0). Viên bi này rơi xuống --, làm giảm bất kỳ viên bi nào bằng 1 (00 quấn quanh và biến thành FF hoặc 255 theo số thập phân). Đá hoa cương với giá trị FF rơi xuống trên \\đó đẩy nó một cột sang phải, xuống phía dưới @0. Đây là một cổng thông tin và dịch chuyển đá cẩm thạch đến @0thiết bị khác . Ở đó, viên bi nằm trên /\thiết bị, là một máy sao chép, nó đặt một bản sao của viên bi ở --bên trái của nó (viên bi này sẽ tiếp tục lặp lại giữa các cổng và được giảm dần trên mỗi vòng) và một cái ở =0bên phải.=0so sánh đá cẩm thạch với giá trị 0 và cho phép đá cẩm thạch rơi xuống nếu nó bằng nhau và đẩy nó sang phải nếu không. Nếu viên bi có giá trị teh 0, nó sẽ rơi vào &0, một bộ đồng bộ, mà tôi sẽ giải thích thêm, sau.

Nói chung, điều này chỉ bắt đầu với một viên bi giá trị 0 trong một vòng lặp và giảm dần cho đến khi nó về 0 lần nữa, sau đó nó đặt viên bi giá trị 0 này vào một bộ đồng bộ hóa và tiếp tục lặp cùng một lúc.

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

}0là một thiết bị đầu vào, ban đầu đầu vào dòng lệnh thứ n (cơ sở 0) khi gọi chương trình được đặt trong mọi }nthiết bị. Vì vậy, nếu bạn gọi chương trình này với đầu vào dòng lệnh 2, một giá trị bằng đá cẩm thạch 02 sẽ thay thế điều này }0. Đá cẩm thạch này sau đó rơi vào &0thiết bị, một bộ đồng bộ hóa khác, &nđồng bộ hóa giữ các viên bi cho đến khi tất cả các ứng dụng tương ứng khác &ncũng được nộp. Đá cẩm thạch sau đó được giảm dần, dịch chuyển và nhân đôi giống như trong vòng lặp được giải thích trước đó. Bản sao bên phải sau đó được kiểm tra bất đẳng thức bằng 0 ( >0) nếu không phải là 0, nó sẽ rơi qua. Nếu là 0, nó bị đẩy sang phải và hạ cánh !!, kết thúc bảng.

Được rồi, cho đến nay chúng ta có một vòng lặp liên tục đếm ngược từ 255 xuống 0 và cho phép một vòng lặp tương tự khác (được cung cấp bởi đầu vào dòng lệnh) chạy một lần mỗi khi nó chạm 0. Khi vòng lặp thứ hai này chạy n lần (tối đa là 256 ) chương trình chấm dứt. Vì vậy, đó là tối đa 65536 lượt chạy của vòng lặp. Không đủ gần để tồn tại lâu hơn vũ trụ.

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

Điều này sẽ bắt đầu trông quen thuộc, đầu vào bị giảm một lần, sau đó giá trị này lặp lại và được sao chép (lưu ý rằng đá cẩm thạch chỉ được giảm một lần, không phải trên mỗi lần chạy vòng lặp). Sau đó, nó được kiểm tra sự bằng nhau về 0 và nếu nó không bằng không MB. Đây là một chức năng trong Marbelous, mỗi tệp có thể chứa một vài bảng và mỗi bảng là một chức năng, mọi chức năng phải được đặt tên bằng cách đặt trước lưới theo :[name]. Mọi chức năng ngoại trừ chức năng đầu tiên trong tệp có tên tiêu chuẩn: MB. Vì vậy, vòng lặp này liên tục gọi lại bảng chính với giá trị trong n - 1đó n là giá trị teh mà phiên bản này của hàm teh được gọi.

Vậy tại sao n*512?

Vâng, vòng lặp đầu tiên chạy trong 4 tích tắc (và 256 lần) và vòng lặp thứ hai chạy n lần trước khi bảng kết thúc. Điều này có nghĩa là bảng chạy cho khoảng n*4*256tick. Vòng lặp cuối cùng (gọi hàm đệ quy) là vi khuẩn và chạy trong 2 tích tắc, có nghĩa là nó quản lý để gọi n*4*256/2 = n*512thời gian của hàm .

Các biểu tượng bạn đã không đề cập là gì?

\/ là một thùng rác, loại bỏ các viên bi khỏi bảng, điều này đảm bảo các viên bi bị loại bỏ không gây trở ngại cho các viên bi khác đang vòng một vòng và ngăn chương trình chấm dứt.

Thêm

Vì các viên bi rơi xuống dưới cùng của một bảng tuyệt vời có được đầu ra cho STDOUT, chương trình này in rất nhiều ký tự ASCII trong khi nó chạy.

Perl, 66 58 ký tự

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

Trên đây là cách thực hiện chức năng Ackermann hè Péter . Tôi không biết A (9,9) lớn đến mức nào nhưng tôi khá chắc chắn rằng sẽ mất một thời gian dài đáng kinh ngạc để đánh giá.

MATLAB, 58 52 ký tự

Chúng ta cần ít nhất một giải pháp số học có độ chính xác hữu hạn, do đó:

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

x = cái (1.999); y = x; trong khi bất kỳ (y), y = mod (y + x, primes (7910)); end

( cảm ơn @DennisJaheruddin vì đã gõ 6 ký tự )

Số chu kỳ cần thiết để hoàn thành được đưa ra bởi sản phẩm của 999 số nguyên tố đầu tiên. Vì phần lớn trong số này đều trên 10, thời gian cần thiết để nhận ra sự hội tụ sẽ là hàng trăm hoặc hàng nghìn đơn đặt hàng có cường độ lớn hơn giới hạn thời gian tối thiểu.

Toán học, 25 19 byte

Giải pháp này đã được đăng trước khi chức năng thời gian bị loại.

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

TimeUsed[]trả về giây kể từ khi phiên bắt đầu và Mathicala sử dụng các loại chính xác tùy ý. Có khoảng 10 ⁷ giây trong một năm, vì vậy chờ 10 ¹⁰⁰⁰⁰ giây là đủ.

Thay thế ngắn hơn / đơn giản hơn (/ hợp lệ):

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

Hãy chỉ tính thay thế. Chúng ta sẽ phải tính thêm một chút, bởi vì chúng ta có thể thực hiện khá nhiều gia số trong một giây, nhưng giới hạn cao hơn không thực sự tốn chi phí ký tự.

Về mặt kỹ thuật, trong cả hai giải pháp, tôi có thể sử dụng giới hạn thấp hơn nhiều vì sự cố không chỉ định tốc độ xử lý tối thiểu.

Con trăn 3 - 49

Điều này thực sự có ích: tính toán Pi với độ chính xác chưa từng có bằng cách sử dụng chuỗi vô hạn Gregory-Leibniz.

Chỉ trong trường hợp bạn đã tự hỏi, chương trình này lặp lại 10**10**10**2.004302604952323lần.

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

Độ chính xác tùy ý: 78

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

Nguồn hình ảnh

Hơi thở thiết bị đầu cuối

Do các tính toán khổng lồ đang diễn ra, việc 1e99**1e99lặp lại chỉ mất vài 1e99**1e99năm. Bây giờ, (1e99**1e99)-1e1000làm cho hầu như không có sự khác biệt. Điều đó có nghĩa là chương trình này sẽ chạy dài hơn nhiều so với cái chết của vũ trụ chúng ta.

Tái sinh

Bây giờ, các nhà khoa học đề xuất rằng trong 10**10**56 years, vũ trụ sẽ được tái sinh do biến động lượng tử hoặc đường hầm. Vậy nếu mỗi vũ trụ giống hệt nhau, chương trình của tôi sẽ sống qua bao nhiêu vũ trụ?

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

Giả sử rằng vũ trụ sẽ luôn sống hàng 1e10+1e1000năm và sau đó mất 10**10**56nhiều năm để 'khởi động lại', chương trình của tôi sẽ sống qua các 1e9701vũ trụ. Tất nhiên, điều này là giả sử rằng unobtainium có thể sống qua Vụ nổ lớn.

Python 59 (hoạt động hầu hết thời gian)

Tôi không thể cưỡng lại

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

Mặc dù đúng là điều này về mặt lý thuyết có thể chấm dứt dưới một phần nghìn giây, thời gian chạy trung bình tốt hơn nhiều 10^400lần so với tuổi thọ được chỉ định của vũ trụ. Cảm ơn @BetaDecay, @undergroundmonorail và @DaboRoss vì đã giảm được 17 ký tự.

J - 5 ký tự, tôi nghĩ

Lưu ý rằng tất cả những điều sau đây là trong số học chính xác tùy ý, bởi vì số 9 luôn có một chút xbên cạnh nó.

Trong bảy nhân vật, chúng ta có !^:!!9x, giống như đang chạy

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

trong số học chính xác tùy ý. Điều này chắc chắn là vượt quá giới hạn bởi vì Synthetica đã nói như vậy , vì vậy chúng tôi có một giới hạn trên.

Trong sáu ký tự, chúng ta cũng có thể viết ^/i.9x, tính toán mọi kết quả trung gian của 0 ^ 1 ^ 2 ^ 3 ^ 4 ^ 5 ^ 6 ^ 7 ^ 8. Wolfram | Alpha nói 2^3^4^5^6^7^8là xấp xỉ 10 ^ 10 ^ 10 ^ 10 ^ 10 ^ 10 ^ 6.65185, có lẽ cũng sẽ xóa kiểm tra.

Chúng tôi cũng có năm char !!!9x, chỉ là ((9!)!)!. W | A nói rằng nó 10 ^ 10 ^ 10 ^ 6.2695vẫn còn đủ lớn ... Đó là những 1.6097e1859933chữ số giống như , lớn hơn nhiều so với 3.154e1016số lượng nano giây trong vũ trụ, nhưng tôi sẽ thừa nhận rằng tôi không biết người ta có thể hiểu như thế nào thời gian thực sự của những điều này.

Tuy nhiên, việc in ấn sẽ mất nhiều thời gian để tồn tại lâu hơn vũ trụ, vì vậy nó sẽ ổn.

C, 63 56 ký tự

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

Điều này dựa trên một ý tưởng của một chàng trai tên là Wilhelm. Đóng góp duy nhất của tôi là cô đọng mã xuống đoạn ngắn (và không thể đọc được) này.

Chứng minh rằng nó chấm dứt được thực hiện bằng cảm ứng.

• Nếu x bằng 0, nó chấm dứt ngay lập tức.
• Nếu nó chấm dứt cho x-1 và bất kỳ y, nó cũng chấm dứt cho x, điều này có thể được hiển thị bằng cảm ứng.

Chứng minh bước cảm ứng bằng cảm ứng:

• Nếu y bằng 0, chỉ có một cuộc gọi đệ quy với x-1, kết thúc bằng giả định cảm ứng.
• Nếu f (x, y-1) chấm dứt thì f (x, y) cũng chấm dứt vì lệnh gọi trong cùng của f chính xác là f (x, y-1) và cuộc gọi ngoài cùng chấm dứt theo giả thuyết cảm ứng.

Thời gian chạy dự kiến ​​là A (9,9) / 11837 giây. Con số này có nhiều chữ số hơn số lượng quark trong vũ trụ quan sát được.

Matlab ( 10 8 ký tự)

1:9e1016

IMHO, hầu hết các mục đang cố gắng quá mức bằng cách tính toán những thứ lớn, phức tạp. Mã này sẽ đơn giản khởi tạo một mảng 9x10 ¹⁰¹⁶ double s đếm từ 1, mất 7,2x10 ^ ¹⁰¹⁷ byte. Trên CPU hiện đại có băng thông bộ nhớ tối đa 21 GB / giây hoặc 6,63x10 ^ ¹⁷ byte / năm , sẽ mất ít nhất 1,09x10 ¹⁰⁰⁰ năm để khởi tạo mảng, chứ đừng nói đến việc in nó vì tôi không bận tâm triệt tiêu đầu ra bằng dấu chấm phẩy. (;

giải pháp cũ

nan(3e508)

Hoặc

inf(3e508)

Mã này chỉ đơn giản sẽ tạo ra một ma trận vuông có NaNs / infinite có kích thước 3e508x 3e508 = 9e10168 byte nhân đôi hoặc 7.2e1017byte.

Perl, 16 ký tự

/$_^/for'.*'x1e9

Điều này xây dựng một chuỗi lặp lại ". ​​*" Một tỷ lần, sau đó sử dụng nó như cả kim và cỏ khô trong một trận đấu regex. Điều này, đến lượt nó, làm cho công cụ regex cố gắng mọi phân vùng có thể có của một chuỗi dài hai tỷ ký tự. Theo công thức này từ Wikipedia , có khoảng 10 ³⁵²¹⁸ phân vùng như vậy.

Giải pháp trên dài 16 ký tự, nhưng chỉ cần khoảng 2Gb bộ nhớ, có nghĩa là nó có thể chạy trên máy tính thực. Nếu chúng ta giả sử bộ nhớ vô hạn và kích thước thanh ghi hữu hạn (có thể không có ý nghĩa), nó có thể được rút ngắn xuống còn 15 ký tự trong khi tăng đáng kể thời gian chạy:

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

(Tôi chưa thử nó, nhưng tôi nghĩ nó có thể hoạt động với Perl 32 bit được xây dựng trên máy 64 bit có ít nhất 6Gb RAM.)

Ghi chú:

• x là toán tử lặp lại chuỗi.
• những forkhông phải là một vòng lặp thực tế; nó chỉ được sử dụng để lưu một ký tự (so với $_=".*"x1e9;/$_^/).
• trận chung kết ^trong regex đảm bảo rằng chỉ chuỗi trống có thể khớp; vì định lượng regex là tham lam theo mặc định, đây là điều cuối cùng động cơ sẽ thử.
• điểm chuẩn trên máy tính của tôi cho các giá trị (1..13) cho thấy thời gian chạy thực sự là O (exp (n)), thậm chí còn nhiều hơn O (exp (sqrt (n))) trong công thức Wikipedia.

J (12)

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

Điều này xuất hiện trong Python (giả sử !hoạt động):

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

BIÊN TẬP:

Chà, chương trình có thể mất tối đa 2 × 10^-1858926vài giây mỗi chu kỳ để hoàn thành trong thời gian cần thiết. Mẹo: điều này thậm chí sẽ không hoạt động trong chu kỳ đầu tiên, đừng bận tâm đến chu kỳ cuối cùng;).

Ngoài ra: chương trình này có thể cần nhiều bộ nhớ hơn là có entropy trong vũ trụ ...

C # 217

Tôi không phải là người chơi gôn nhiều, nhưng tôi không thể cưỡng lại chức năng của Ackerman . Tôi cũng không thực sự biết cách tính thời gian chạy, nhưng nó chắc chắn sẽ dừng lại và chắc chắn nó sẽ chạy lâu hơn phiên bản này .

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));}
}

Nỗ lực đầu tiên tại mã golf nhưng ở đây đi.

VBA - 57 45

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

Vì vậy, X sẽ tăng lên một nếu sự kiện 1 trong 2 ^ 128 xảy ra và đặt lại nếu nó không xảy ra. Mã kết thúc khi sự kiện này xảy ra 2 ^ 64 + 1 lần liên tiếp. Tôi không biết làm thế nào để bắt đầu tính toán thời gian nhưng tôi đoán nó rất lớn.

EDIT: Tôi đã giải toán và xác suất xảy ra trong mỗi vòng lặp là 1 trên 2 ^ 128 ^ (1 + 2 ^ 64) dài khoảng 20000 chữ số. Giả sử 1000000 vòng / giây (sân bóng ngoài số không khí mỏng) và 30000000 giây / năm, đó là 3 * 10 ^ 13 chu kỳ mỗi năm thời gian 10 ^ 1000 năm còn lại là 3 * 10 ^ 1013 chu kỳ, do đó, điều này có thể sẽ kéo dài khoảng 20 lần thời gian còn lại trong vũ trụ. Tôi vui vì toán học của tôi sao lưu trực giác của tôi.

C, 30 ký tự

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

Giả sử hai lời khen được ký kết tràn và int 32 bit, điều này sẽ chạy trong khoảng 2 ^{2 32} lệnh gọi hàm, sẽ có nhiều thời gian để vũ trụ kết thúc.

GolfScript, 13 ký tự

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

Chương trình này chỉ đếm từ 0 đến 10 ^{9 9 1} = 10 ^387420488 . Giả sử, một cách lạc quan, máy tính chạy ở tốc độ 100 GHz và có thể thực hiện mỗi lần lặp của chương trình trong một chu kỳ, chương trình sẽ chạy trong 10 ^{9 9 −12} giây, hoặc khoảng 3 × 10 ^{9 9 −20} = 3 × 10 ^387420469 năm

Để kiểm tra chương trình, bạn có thể thay thế 9bằng a 2, điều này sẽ làm cho nó dừng ở 10 ^{2 2 1} = 10 ³ = 1000. (Sử dụng 3thay vì a 2sẽ làm cho nó dừng ở 10 ^{3 3 1} = 10 ²⁶ , , ngay cả với các giả định lạc quan ở trên, nó sẽ không đạt được ít nhất vài triệu năm.)

Autohotkey 37

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

Haskell, 23

main=interact$take$2^30

Chương trình này chấm dứt sau khi đọc 1073741824 ký tự từ stdin. Nếu nó chạy mà không có bất kỳ dữ liệu nào stdin, bạn sẽ phải nhập số ký tự này trên bàn phím. Giả sử bàn phím của bạn có 105 phím, mỗi phím được định mức cho 100k chu kỳ cơ học và được lập trình để tạo ra các tổ hợp phím không chết, tự động tắt và ổ cắm bàn phím của bạn cho phép 100 chu kỳ kết nối, điều này cho số lần nhấn phím tối đa trên mỗi máy tính là 1050000000, đó là không đủ để chương trình chấm dứt.

Do đó, chương trình sẽ chỉ chấm dứt khi phần cứng tốt hơn trở nên khả dụng về số lượng chu kỳ, điều này thực sự không bao giờ có trong vũ trụ đang chạy này. Có thể lần sau, khi chất lượng có mức độ ưu tiên cao hơn số lượng. Cho đến lúc đó, chương trình này chấm dứt trên nguyên tắc nhưng không thực tế.

~ ATH, 56

Trong ngôn ngữ hư cấu ~ ATH :

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

~ ATH là một ngôn ngữ không thể vượt qua để làm việc với. Logic của nó bao gồm không có gì ngoài các vòng lặp vô hạn, hoặc tốt nhất, các vòng lặp của việc xây dựng kết hợp hiệu quả.

Điều mà nhiều lập trình viên ATH làm là nhập các cấu trúc hữu hạn và liên kết các vòng lặp với tuổi thọ của chúng. Chẳng hạn, vòng lặp chính ở đây sẽ chấm dứt cái chết của vũ trụ, được gắn nhãn U. Bằng cách đó, bạn chỉ phải đợi hàng tỷ năm để nó kết thúc thay vì mãi mãi.

Tôi xin lỗi vì vi phạm kẽ hở biên giới; Tôi nghĩ rằng nó là quá liên quan để vượt qua.

Nếu bất cứ ai thực sự thích thú với điều này, chi tiết hơn: (1) , (2) , (3) , (4)

Hồng ngọc (34)

Dòng ([0]*9).permutation.each{print}này mất khoảng 2,47 giây trong 9! in trên máy của tôi, trong khi dòng ([0]*10).permutation.each{print}mất khoảng 24,7 giây trong 10! bản in, vì vậy tôi đoán rằng tôi có thể ngoại suy ở đây và tính toán (24.7/10!)*470! seconds in yearsđó là 6,87 * 10 ^ 1040, đây sẽ là thời gian chạy của:

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

JavaScript 68 62 ký tự

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

Cái này sử dụng hàm Ackermann có thể được viết là

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));
}

Thời gian chạy của nó tăng theo cấp số nhân và do đó mất rất nhiều thời gian để tính toán. Mặc dù nó không phải là tiếng Anh ở đây, bạn có thể có được cái nhìn tổng quan về các giá trị trả về của nó. Theo bảng ackermann(5,1)bằng 2↑↑(65533)-3, đó là, rất lớn.

Befunge '93 - 40 byte

(Chương trình 20x2)

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

Chương trình này dựa vào các số ngẫu nhiên để cung cấp cho nó độ trễ. Vì thông dịch viên Befunge khá chậm, chương trình này sẽ phù hợp với hóa đơn. Và nếu không, chúng ta luôn có thể mở rộng theo chiều ngang. Tôi không chắc chắn chính xác làm thế nào để tính toán thời gian chạy dự kiến ​​của chương trình này, nhưng tôi biết rằng mỗi? có 50/50 cơ hội bắt đầu lại hoặc thay đổi vị trí nằm ngang của nó bằng 1. Có 18? Tôi nghĩ rằng nó phải là một cái gì đó dọc theo dòng (18 ^ 2)!, Mà máy tính google nói là "Vô cực"

EDIT: Rất tiếc tôi đã không nhận thấy câu trả lời Befunge khác, đây là bài viết đầu tiên của tôi ở đây. Lấy làm tiếc.

APL, 10

Tôi không nghĩ rằng đây là một câu trả lời hợp lệ (vì nó không mang tính quyết định), nhưng dù sao thì ......

{?⍨1e9}⍣≡1

Chương trình này tính toán hoán vị ngẫu nhiên 1e9 số ( ?⍨1e9) và lặp lại cho đến khi hai đầu ra liên tiếp bằng nhau ( ⍣≡)

Vì vậy, mỗi khi tính toán hoán vị, nó có 1 trên 1000000000! cơ hội chấm dứt. Và 1000000000! ít nhất là 10 ^{10 8} .

Thời gian cần thiết để tính toán hoán vị được đưa ra không liên quan bởi tính đại chúng của 1000000000!. Nhưng một số thử nghiệm cho thấy điều này là O(n)và ngoại suy cho khoảng 30 giây.

Tuy nhiên, trình thông dịch của tôi từ chối đưa đầu vào vào hàm ngẫu nhiên lớn hơn 2 ³¹ -1 (vì vậy tôi đã sử dụng 1e9) và tạo ra hoán vị 1000000000 số đã gây ra lỗi toàn bộ không gian làm việc. Tuy nhiên, về mặt khái niệm nó có thể được thực hiện với một trình thông dịch APL lý tưởng với bộ nhớ vô hạn.

Điều này dẫn chúng ta đến khả năng sử dụng 2 ⁶³ -1 thay cho 1e9 để tăng thời gian chạy lên đến ít nhất 10 ^{10 20} , giả sử kiến ​​trúc 64 bit.

Nhưng chờ đã, kiến ​​trúc có liên quan trong một phiên dịch lý tưởng không? Địa ngục không vì vậy thực sự không có giới hạn trên về thời gian chạy !!

R, 45 byte

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

Đó là một chủ đề cũ nhưng tôi thấy không có câu trả lời R, và chúng ta không thể có điều đó!

Thời gian chạy đối với tôi là khoảng 1 giây khi x 20, cho thấy thời gian chạy là 2 ^ 9979 giây.

Nếu bạn thay số 0 bằng một, thì đầu ra sẽ là 2 ^ x, nhưng vì nó đứng đầu ra bằng 0 dù x là gì (tránh các vấn đề tràn).

Javascript, 120 byte

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)

Có thể được thực hiện với bộ nhớ tối thiểu (có thể ít hơn nửa megabyte) nhưng phải mất (có thể) khoảng 10 ^8.750 năm để tạm dừng.

Liên tục tăng một căn cứ nhỏ-9 BigInteger cho đến khi nó đạt đến 9 ^{10 4 -1} .

Python 3, 191 byte

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)

Đầu tiên, f là hàm nhân tử đệ quy và cực chậm. Sau đó, có 9 * 10⁹⁹⁹ powed với chính nó, tạo ra OverflowError, nhưng điều này không xảy ra trên máy tính Un phô trương này. Vòng lặp For lặp 9E999! ^ (9E999 ^ 9E999)! lần và nó chỉ chuyển sang lần lặp tiếp theo, nếu 9E999! +1 ints ngẫu nhiên trong khoảng từ 0 đến 9E99 * ^ i! đều là 0 và trong mỗi lần lặp của vòng lặp while được đặt thành (9E999 ^ s)!. Uh, tôi quên rằng việc in s mất thời gian muuuuccchhhh ...
Tôi biết đó không phải là giải pháp ngắn nhất, nhưng tôi nghĩ nó thực sự hiệu quả. Ai đó có thể giúp tôi tính toán thời gian chạy không?

Máy Turing nhưng cách tệ hơn , 167 byte

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

Hãy thử trực tuyến!

Nên chạy Busy Beaver 6 ký hiệu 2 trạng thái từ trang Wikipedia .

$7.412 \times 10^{36534}$