Mục tiêu của bạn là viết một chương trình in một số. Con số càng lớn, bạn càng nhận được nhiều điểm. Nhưng hãy cẩn thận! Độ dài mã vừa bị giới hạn vừa có trọng số lớn trong chức năng tính điểm. Số in của bạn sẽ được chia cho khối lập phương của số byte bạn đã sử dụng cho giải pháp của mình .

Vì vậy, giả sử bạn đã in 10000000và mã của bạn 100dài byte. Điểm cuối cùng của bạn sẽ là 10000000 / 100^3 = 10.

Có những quy tắc khác phải tuân theo, để làm cho thử thách này khó hơn một chút.

• Bạn không thể sử dụng các chữ số trong mã của mình (0123456789);
• Bạn có thể sử dụng toán học / vật lý / vv. các hằng số, nhưng chỉ khi chúng nhỏ hơn 10. (ví dụ: Bạn có thể sử dụng Pi ~ = 3.14 nhưng bạn không thể sử dụng hằng số Avogadro = 6e23)
• Đệ quy được cho phép nhưng số được tạo cần phải hữu hạn (vì vậy vô hạn không được chấp nhận như một giải pháp. Chương trình của bạn cần chấm dứt chính xác, giả sử thời gian và bộ nhớ không giới hạn và tạo đầu ra được yêu cầu);
• Bạn không thể sử dụng các hoạt động *(nhân), /(chia), ^(sức mạnh) cũng như bất kỳ cách nào khác để chỉ ra chúng (ví dụ: 2 div 2không được phép);
• Chương trình của bạn có thể xuất nhiều hơn một số, nếu bạn cần nó để làm điều đó . Chỉ người cao nhất sẽ được tính cho điểm;
• Tuy nhiên, bạn có thể nối các chuỗi: điều này có nghĩa là bất kỳ chuỗi các chữ số liền kề sẽ được coi là một số duy nhất;
• Mã của bạn sẽ được chạy như vốn có. Điều này có nghĩa là người dùng cuối không thể chỉnh sửa bất kỳ dòng mã nào, anh ta cũng không thể nhập một số hoặc bất cứ thứ gì khác;
• Độ dài mã tối đa là 100 byte.

Bảng xếp hạng

1. Steven H. , Pyth ≈ f _{φ (1,0,0) +7} (256 ²⁶ ) / 1000000 ^[1]
2. Nghệ thuật đơn giản đẹp , Ruby f _{φ 121 ()} (126) ^[1]
3. Peter Taylor , GolfScript ≈ f _{ε 0 + + 1} (17) / 1000 ^[1]
4. res , GolfScript ≈ f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126))))))))) ^[1]
5. Nghệ thuật đơn giản là đẹp , Ruby ≈ f _{ω ⁺¹² +1} (1983)
6. eaglgenes101 , Julia f _ω3 (127)
7. col6y , Python 3, ≈ (127 → 126 → ... → 2 → 1) / 99 ^{3 [1] [3]}
8. Toeofdoom , Haskell, ≈ a ₂₀ (1) / 99 ^{3 [1]}
9. Fraxtil , dc, ≈ 15 ↑ 15/100 ^{3 [3]}
10. Đỏ tươi , Python, ≈ ack (126.126) / 100 ³ 10 ↑ ¹²⁴ 129
11. Kendall Frey , 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. đệ quy , Python, ≈ 2 ↑↑ 11/95 ³ 10 ↑↑ 8.63297 ^{[1] [3]}
15. nm , Haskell, ≈ 2 ↑↑ 7/100 ³ 10 ↑↑ 4.63297 ^[1]
16. David Yaw , C, ≈ 10 ^{10 4 × 10 22} /83 ³ ≈ 10 ↑↑ 4,11821 ^[2]
17. primo , Perl, ≈ 10 ^{(12750684161) 5 × 2 27} /100 ³ ≈ 10 ↑↑ 4,11369
18. Nghệ thuật , C, ≈ 10 ^{10 2 × 10 6} /98 ³ ≈ 10 ↑↑ 3,80587
19. Robert Sørlie , x86, ≈ 10 ^{2 2 19 +32} / 100 ³ 10 3.71585
20. Tobia , APL, ≈ 10 ^{10 353} /100 ³ ≈ 10 ↑↑ 3,40616
21. Đá Darren , C, ≈ 10 ^{10 97.61735} / 98 ³ 10 ↑↑ 3.29875
22. ecksemmess , C, ≈ 10 ^{2 320} /100 ³ ≈ 10 ↑↑ 3,29749
23. Adam Speight , vb.net, ≈ 10 ^{5000 × (2 64 ) 4} /100 ³ ≈ 10 ↑↑ 3,28039
24. Giô-suê , bash, ≈ 10 ^{10 15} /86 ³ ≈ 10 ↑↑ 3,07282

_{Chú thích}

1. ^{Nếu mọi điện tử trong vũ trụ là một qubit và mọi sự chồng chất của chúng có thể được sử dụng một cách hữu ích để lưu trữ thông tin (miễn là bạn không thực sự cần biết những gì được lưu trữ về mặt lý thuyết là có thể), chương trình này đòi hỏi nhiều bộ nhớ hơn có thể có thể tồn tại và do đó không thể chạy được - ngay bây giờ hoặc tại bất kỳ thời điểm nào có thể hiểu được trong tương lai. Nếu tác giả dự định in một giá trị lớn hơn ≈3 ↑↑ 3,28 cùng một lúc, điều kiện này sẽ được áp dụng.}
2. ^{Chương trình này đòi hỏi nhiều bộ nhớ hơn hiện tại, nhưng không nhiều đến mức về mặt lý thuyết nó không thể được lưu trữ trên một số lượng ít qubit, và do đó một máy tính có thể tồn tại một ngày nào đó có thể chạy chương trình này.}
3. ^{Tất cả các thông dịch viên hiện đang có lỗi thời gian chạy hoặc chương trình không thực thi như tác giả dự định.}
4. ^{Chạy chương trình này sẽ gây ra thiệt hại không thể khắc phục cho hệ thống của bạn.}

Chỉnh sửa @primo : Tôi đã cập nhật một phần của bảng điểm bằng cách sử dụng một ký hiệu hy vọng dễ dàng hơn để so sánh, với số thập phân để biểu thị khoảng cách logarit với sức mạnh cao hơn tiếp theo. Ví dụ 10 ↑↑ 2,5 = 10 ^{10 √10} . Tôi cũng đã thay đổi một số điểm nếu tôi cho rằng phân tích của người dùng bị lỗi, cứ thoải mái tranh chấp bất kỳ điểm nào trong số này.

Giải thích về ký hiệu này:

Nếu 0 ≤ b < 1, sau đó .a↑↑b = ab

Nếu b ≥ 1, sau đó .a↑↑b = aa↑↑(b-1)

Nếu b < 0, sau đó .a↑↑b = loga(a↑↑(b+1))

GolfScript; điểm tối thiểu f _{ε_0 + + 1} (17) / 1000

Theo đề nghị của res để sử dụng câu trả lời trọn đời cho một câu trả lời sâu cho câu hỏi này, tôi trình bày hai chương trình cải thiện đáng kể sự xuất phát từ giải pháp của Howard.

Chúng có chung một tiền tố chung, modulo tên hàm:

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

tính toán g(g(1)) = g(5)nơi g(x) = worm_lifetime(x, [x])tăng trưởng xấp xỉ f _{ε 0} (mà res ghi chú là "hàm trong hệ thống phân cấp phát triển nhanh , tăng trưởng với tốc độ gần bằng với hàm Goodstein").

Phân tích dễ hơn một chút (!) Là

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

.{foo}*bản đồ xđến foo^x x.

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

do đó cho g^(g(5)) ( g(5) ); 8 cấp độ lặp tiếp theo tương tự như chuỗi mũi tên. Để diễn đạt bằng các thuật ngữ đơn giản: nếu h_0 = gvà h_{i+1} (x) = h_i^x (x)sau đó chúng tôi tính toán h_10 (g(5)).

Tôi nghĩ rằng chương trình thứ hai này gần như chắc chắn điểm số tốt hơn nhiều. Lần này nhãn được gán cho chức năng glà một dòng mới (sic).

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

Lần này tôi sử dụng tốt hơn ^như là một chức năng khác.

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

lấy xtrên ngăn xếp và các lá xtiếp theo là một chuỗi chứa các xbản sao .{theo gsau là các xbản sao của }*; sau đó đánh giá chuỗi. Vì tôi có một nơi tốt hơn để đốt các nhân vật dự phòng, chúng tôi bắt đầu với j_0 = g; nếu j_{i+1} (x) = j_i^x (x)sau đó đánh giá đầu tiên của máy ^tính j_{g(5)} (g(5))(mà tôi khá chắc chắn đã đánh bại chương trình trước đó). Sau đó tôi thực hiện ^thêm 16 lần nữa; vì vậy nếu k_0 = g(5)và k_{i+1} = j_{k_i} (k_i)sau đó nó tính toán k_17. Tôi rất biết ơn (một lần nữa) vì đã ước tính rằng k_i>> f _{_0 + + 1} (i).

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

LƯU Ý: ĐỪNG CHẠY NÀY!

Lưu các mục sau vào một tệp bó và chạy nó với tư cách Quản trị viên.

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

Xuất ra khi chạy trên ổ đĩa 4TB với số in đầu tiên được in đậm.

Chèn đĩa mới cho ổ D:
và nhấn ENTER khi sẵn sàng ... Loại hệ thống tệp là NTFS.
Hệ thống tập tin mới là FAT.
QuickFormatted 3907172M
Âm lượng quá lớn đối với FAT16 / 12.

GolfScript, điểm số: cách quá nhiều

OK, một số lượng lớn chúng ta có thể in trong một vài ký tự GolfScript như thế nào?

Hãy bắt đầu với đoạn mã sau ( cảm ơn, Ben! ), In ra 126:

'~'(

Tiếp theo, hãy lặp lại nó 126 lần, cho chúng ta một số bằng khoảng 1,26126 × 10 ³⁷⁷ :

'~'(.`*

(Đó là sự lặp lại chuỗi, không phải là phép nhân, vì vậy nó sẽ ổn theo quy tắc.)

Bây giờ, chúng ta hãy lặp lại rằng số 378 chữ số một ít hơn 10 ³⁷⁷ lần:

'~'(.`*.~*

Bạn sẽ không bao giờ thực sự thấy chương trình này kết thúc, vì nó cố gắng tính một số có khoảng 10 ³⁸⁰ 2 ¹¹⁴⁰ chữ số. Không có máy tính nào được chế tạo có thể lưu trữ một số lượng lớn như vậy, cũng không thể chế tạo một máy tính như vậy bằng vật lý đã biết; các số nguyên tử trong vũ trụ quan sát được được ước tính là khoảng 10 ⁸⁰ , vì vậy ngay cả nếu chúng ta bằng cách nào đó có thể sử dụng tất cả các vấn đề này trong vũ trụ để lưu trữ số lượng lớn này, chúng tôi vẫn bằng cách nào đó phải nhồi nhét khoảng 10 ³⁸⁰ /10 ⁸⁰ = 10 ³⁰⁰ chữ số vào mỗi nguyên tử!

Nhưng hãy giả sử rằng chúng tôi có trình thông dịch GolfScript của chính Chúa, có khả năng chạy một phép tính như vậy và chúng tôi vẫn chưa hài lòng. OK, hãy làm điều đó một lần nữa!

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

Đầu ra của chương trình này, nếu có thể hoàn thành, sẽ có khoảng 10 ^{10 383} chữ số và do đó sẽ bằng khoảng 10 ^{10 10 383} .

Nhưng chờ đã! Chương trình đó đang trở nên lặp đi lặp lại ... tại sao chúng ta không biến nó thành một vòng lặp?

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

Ở đây, thân vòng lặp được chạy khoảng 10 ³⁷⁷ lần, cho chúng ta một đầu ra lý thuyết bao gồm khoảng 10 ^{10⋰ 10 377} chữ số hoặc hơn, trong đó tháp có sức mạnh lặp 10 dài khoảng 10 ³⁷⁷ bước. .

Nhưng chúng tôi chưa hoàn thành. Hãy thêm một vòng lặp nữa!

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

Để thậm chí viết đúng một xấp xỉ các số như vậy đòi hỏi phải có ký hiệu toán học bí truyền. Ví dụ, trong ký hiệu mũi tên Knuth , đầu ra số (theo lý thuyết) của chương trình trên phải vào khoảng 10 ↑ ³ 10 ³⁷⁷ , cho hoặc nhận một vài (hoặc 10 ³⁷⁷ ) ^lũy thừa mười, giả sử tôi đã làm đúng phép toán.

Những con số như thế này vượt xa "vô cùng lớn" và đi vào cõi "không thể tưởng tượng được". Như trong, không chỉ không thể đếm hoặc viết ra những con số như vậy (chúng tôi đã vượt qua điểm đó ở ví dụ thứ ba ở trên), nhưng theo nghĩa đen chúng không có cách sử dụng hay tồn tại bên ngoài toán học trừu tượng. Chúng ta có thể chứng minh, từ các tiên đề của toán học , rằng những con số như vậy tồn tại, giống như chúng ta có thể chứng minh từ đặc tả GolfScript mà chương trình ở trên sẽ tính toán chúng, nếu giới hạn của thực tế và không gian lưu trữ có sẵn không can thiệp), nhưng thực sự không có gì trong vũ trụ vật lý mà chúng ta có thể sử dụng chúng để đếm hoặc đo theo bất kỳ ý nghĩa nào.

Tuy nhiên, các nhà toán học đôi khi sử dụng số lượng lớn hơn . (Lý thuyết) số máy tính mà lớn có làm việc nhiều hơn một chút - thay vì chỉ làm tổ hơn vòng từng người một, chúng ta cần phải sử dụng đệ quy để kính thiên văn các chiều sâu của các vòng lồng nhau. Tuy nhiên, về nguyên tắc, có thể viết một chương trình GolfScript ngắn (dưới 100 byte, tôi mong đợi) để tính toán (về mặt lý thuyết) bất kỳ số nào có thể biểu thị trong, ví dụ, ký hiệu chuỗi mũi tên Conway ; các chi tiết còn lại như một bài tập. ;-)

JavaScript 44 ký tự

Điều này có vẻ hơi gian lận:

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

Điểm = 31415926535897932718281828459045/44 ^ 3 ≈ 3.688007904758867e + 26 10 ↑↑ 2.1536134004

C, điểm = 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);}

Tôi đánh giá cao sự giúp đỡ trong việc ghi bàn. Bất kỳ hiểu biết hoặc sửa chữa được đánh giá cao. Đây là phương pháp của tôi:

n = phép nối của mọi số từ 1 đến 2 ⁶⁴ -1, lặp lại (2 ⁶⁴ -1) ⁴ lần . Đầu tiên, đây là cách tôi ước tính (thấp) số chữ số tích lũy từ 1 đến 2 ⁶⁴ -1 ("chuỗi"): Số cuối cùng trong chuỗi thứ tự là 2 ⁶⁴ -1 = 18446744073709551615với 20 chữ số. Do đó, hơn 90% các số trong phần tiếp theo (những số bắt đầu bằng 1.. 9) có 19 chữ số. Giả sử 10% còn lại trung bình 10 chữ số. Nó sẽ nhiều hơn thế, nhưng đây là một ước tính thấp cho toán dễ dàng và không gian lận. Dãy đó được lặp đi lặp lại (2 ⁶⁴ -1) ⁴ lần, vì vậy độ dài của n sẽít nhất (0,9 × (2 ⁶⁴ -1) × 19 + 0,1 × (2 ⁶⁴ -1) × 10) × (2 ⁶⁴ -1) ⁴ = 3,86613 × 10 ⁹⁷ chữ số. Trong các bình luận bên dưới, @primo xác nhận độ dài của n là 4,1433x10 ⁹⁷ . Vì vậy, bản thân n sẽ là 10 với sức mạnh đó, hoặc 10 ^{10 97.61735} .

tôi = 98 ký tự mã

điểm = n / l ³ = 10 ^{10 97.61735} / 98 ³

Yêu cầu: Phải chạy trên máy tính 64 bit sizeof(long) == 8. Mac và Linux sẽ làm điều đó.

Python 3 - 99 ký tự - (rất có thể) lớn hơn đáng kể so với số của Graham

Tôi đã đưa ra một chức năng tăng nhanh hơn dựa trên một phần mở rộng của chức năng 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 đã truyền cảm hứng cho tôi, nhưng bạn không cần phải nhìn vào đó để hiểu số của tôi.

Đây là phiên bản sửa đổi của hàm ackermann mà tôi sẽ sử dụng trong phân tích của mình:

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,...),...)

Hàm của tôi Atrong đoạn mã trên về mặt kỹ thuật không giống nhau, nhưng nó thực sự mạnh hơn, với câu lệnh sau để thay thế dòng thứ ba của định nghĩa trên:

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

(a phải có ít nhất 1, vì vậy nó phải mạnh hơn)

Nhưng với mục đích của tôi, tôi sẽ cho rằng nó giống như đơn giản hơn, vì phân tích đã được thực hiện một phần cho chức năng của Ackermann, và do đó cho chức năng này khi nó có hai đối số.

Hàm của tôi được đảm bảo cuối cùng sẽ dừng đệ quy vì nó luôn luôn: xóa một đối số, giảm đối số thứ nhất hoặc giữ nguyên đối số thứ nhất và giảm đối số thứ hai.

Phân tích kích thước

Số của Graham, AFAIK, có thể được biểu diễn G(64)bằng cách sử dụng:

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

Trong đó một ↑^(n)b là ký hiệu mũi tên lên của knuth.

Cũng:

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)

Con số thể hiện trong chương trình trên là A(0,1,2,3,4,...,123,124,125) .

Vì g^64(4)là số của Graham và giả sử toán của tôi là chính xác thì nó nhỏ hơn A(1,64,100), số của tôi lớn hơn đáng kể so với số của Graham.

Vui lòng chỉ ra bất kỳ sai lầm nào trong toán học của tôi - mặc dù nếu không có lỗi nào, đây sẽ là con số lớn nhất được tính toán cho đến nay để trả lời câu hỏi này.

Perl - điểm 10 ↑↑ 4.1

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

Một lần nữa lạm dụng công cụ regex của perl để nghiền nát một lượng kết hợp không thể tưởng tượng được, lần này sử dụng một hậu duệ đệ quy.

Trong phần lớn của biểu thức, chúng ta có một trần . để ngăn chặn đệ quy vô hạn, và do đó hạn chế mức độ đệ quy với độ dài của chuỗi.

Những gì chúng ta sẽ kết thúc là đây:

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

... lặp đi lặp lại 671088640 lần, với tổng số 12750684161 lần làm tổ - điều này hoàn toàn đặt ra nỗ lực trước đây của tôi là 23 làm tổ bị xấu hổ. Đáng chú ý, perl thậm chí không bị sặc về điều này (một lần nữa, việc sử dụng bộ nhớ giữ ổn định ở mức khoảng 1,3 GB), mặc dù sẽ mất khá nhiều thời gian trước khi tuyên bố in đầu tiên được phát hành.

Từ phân tích trước đây của tôi dưới đây, có thể kết luận rằng số lượng chữ số đầu ra sẽ theo thứ tự (! 12750684161) ^671088640 , trong đó ! K là Yếu tố còn lại của k (xem A003422 ). Chúng ta có thể ước chừng điều này là (k-1)! , đó là hoàn toàn nhỏ hơn, nhưng trên cùng một thứ tự cường độ.

Và nếu chúng ta hỏi wolframalpha :

... mà hầu như không thay đổi điểm số của tôi cả. Tôi nghĩ chắc chắn rằng ít nhất là 10 5 . Tôi đoán sự khác biệt giữa 10 ↑↑ 4 và 10 4.1 lớn hơn nhiều so với bạn nghĩ.

Perl - điểm 10 ↑↑ 4

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

Lạm dụng công cụ regex perl để làm một số tổ hợp cho chúng tôi. Các codeblock được nhúng
(??{print})sẽ chèn kết quả của nó trực tiếp vào regex. Vì $_được cấu tạo hoàn toàn bằng 2s (và kết quả printlà luôn luôn 1), nên điều này không bao giờ có thể khớp và gửi perl spin qua tất cả các kết hợp có thể, trong đó có khá nhiều.

Hằng số sử dụng

• $^F- xử lý tập tin hệ thống tối đa, điển hình 2.
• $]- số phiên bản perl, tương tự như 5.016002.

$_sau đó là một chuỗi chứa chữ số 2lặp lại 671088640 lần. Sử dụng bộ nhớ không đổi ở mức khoảng 1,3 GB, đầu ra bắt đầu ngay lập tức.

Phân tích

Hãy xác định P _k (n) là số lần câu lệnh in được thực thi, trong đó k là số lần lồng và n là độ dài của chuỗi cộng với một (chỉ vì tôi không cảm thấy như viết n + 1 mọi nơi).

(.*.*)*
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, ... ]

vv Nói chung, công thức có thể được khái quát như sau:

Ở đâu

Đó là, Yếu tố còn lại của k , tức là tổng của tất cả các yếu tố nhỏ hơn k (xem A003422 ).

Tôi đã không thể xác định các hình thức đóng cho D _k và E _k , nhưng điều này không quá quan trọng, nếu chúng tôi quan sát thấy rằng

và

Với 23 lần lồng, điều này cho chúng ta một số điểm gần đúng:

Điều này nên gần như chính xác, thực sự.

Nhưng để đưa ra một ký hiệu dễ hình dung hơn một chút, chúng ta có thể tính gần đúng cơ sở của số mũ bên trong:

và sau đó là số mũ:

và sau đó hỏi wolframalpha :

mà bạn có thể chỉ cần gọi 10 4 và được thực hiện với nó.

Javascript, 10 ↑↑↑↑ 210

100 ký tự:

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)

Dựa trên quan sát rằng lặp đi lặp lại tối đa flà cách tối ưu, tôi đã thay thế 13 cuộc gọi fbằng 3 cấp độ của các vòng lặp lồng nhau f, zmỗi lần gọi (trong khi fvẫn tăngz ).

Tôi ước tính điểm số một cách phân tích trên một mảnh giấy mà tôi sẽ gõ nó nếu có ai muốn xem nó.

Điểm được cải thiện: 10 13

Javascript, trong chính xác 100 ký tự, một lần nữa:

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)

Điều này cải thiện câu trả lời ban đầu của tôi theo ba cách

1. Xác định ztrên phạm vi toàn cầu giúp chúng ta không phải gõ o.zmỗi lần.

2. Có thể định nghĩa một getter trên phạm vi toàn cầu (cửa sổ) và gõ fthay vì o.f.

3. Có nhiều lần lặp lại fcó giá trị hơn so với bắt đầu với số lớn hơn, vì vậy thay vì (Math.E+'').replace('.','')(= 2718281828459045, 27 ký tự), tốt hơn là sử dụng ~~Math.E+''(= 2, 11 ký tự) và sử dụng các ký tự được trục vớt để gọi fnhiều lần hơn.

Vì, như được phân tích sâu hơn bên dưới, mỗi lần lặp tạo ra, từ một số theo thứ tự cường độ M , một số lớn hơn theo thứ tự cường độ 10 ^M , mã này tạo ra sau mỗi lần lặp

1. 210 O (10 ² )
2. Ôi (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. Ô (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)

Điểm: 10 ^{10 10 10 10 16} 10 ↑↑ 6.080669764

Javascript, trong chính xác 100 ký tự:

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)

Mỗi o.fvòng gọi vòng lặp while, với tổng số 5 vòng. Chỉ sau lần lặp đầu tiên, điểm số đã vượt quá 10 ^{42381398144233621} . Đến lần lặp thứ hai, Mathicala không thể tính được ngay cả số chữ số trong kết quả.

Đây là một hướng dẫn của mã:

Trong đó

Bắt đầu với 2718281828459045 bằng cách xóa dấu thập phân khỏi Math.E.

Lặp lại 1

Nối chuỗi số giảm dần,

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

để tạo thành một số mới (khổng lồ),

• 271828182845904527182818284590442718281828459043 ... 9876543210.

Có bao nhiêu chữ số trong số này? Vâng, đó là sự kết hợp của

• 1718281828459046 Số 16 chữ số
• 900000000000000 Số gồm 15 chữ số
• 90000000000000 Số có 14 chữ số,
• 9000000000000 số có 13 chữ số
• ...
• 900 số có 3 chữ số
• 90 số có 2 chữ số
• 10 số có 1 chữ số

Trong Mathicala,

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

Nói cách khác, đó là 2,72⋅10 ^{42381398144233625} .

Ghi điểm của tôi, chỉ sau lần lặp đầu tiên, 2,72⋅10 ^{42381398144233619} .

Lặp lại 2

Nhưng đó mới chỉ là khởi đầu. Bây giờ, lặp lại các bước, bắt đầu với số lượng khổng lồ ! Đó là, nối chuỗi số giảm dần,

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

Vì vậy, điểm số mới của tôi, Mathematica là gì?

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[]

Lặp lại 3

Nói lại.

Lặp lại 4

Nói lại.

Lặp lại 5

Nói lại.

Điểm phân tích

Trong lần lặp đầu tiên, chúng tôi đã tính số chữ số trong phép nối chuỗi giảm dần bắt đầu từ 2718281828459045, bằng cách đếm số chữ số trong

• 1718281828459046 Số 16 chữ số
• 900000000000000 Số gồm 15 chữ số
• 90000000000000 Số có 14 chữ số,
• 9000000000000 số có 13 chữ số
• ...
• 900 số có 3 chữ số
• 90 số có 2 chữ số
• 10 số có 1 chữ số

Tổng này có thể được biểu diễn bằng công thức,

trong đó Z biểu thị số bắt đầu ( ví dụ 2718281828459045) và O _Z biểu thị thứ tự độ lớn của nó ( ví dụ 15, kể từ Z 10 ¹⁵ ). Sử dụng tương đương cho các khoản tiền hữu hạn , ở trên có thể được thể hiện rõ ràng như

mà, nếu chúng ta mất 9 ≈ 10, sẽ giảm hơn nữa

và cuối cùng, mở rộng các điều khoản và sắp xếp chúng theo thứ tự độ lớn giảm dần, chúng ta có được

Bây giờ, vì chúng ta chỉ quan tâm đến thứ tự độ lớn của kết quả, hãy thay thế Z bằng "một số theo thứ tự độ lớn của O _Z ", tức là 10 ^{O _Z} -

Cuối cùng, các điều khoản thứ 2 và thứ 3 hủy bỏ và hai điều khoản cuối cùng có thể được loại bỏ (kích thước của chúng là tầm thường), để lại cho chúng tôi

từ đó nhiệm kỳ đầu tiên thắng

Được phục hồi, flấy một số theo thứ tự độ lớn của M và tạo ra một số xấp xỉ theo thứ tự độ lớn của M (10 ^M ).

Lặp lại đầu tiên có thể dễ dàng được kiểm tra bằng tay. 2718281828459045 là một số theo thứ tự cường độ 15 Do đó fnên tạo ra một số theo thứ tự cường độ 15 (10 ¹⁵ ) 10 ¹⁶ . Thật vậy, số lượng được sản xuất là, từ trước đó, 2,72⋅10 ^{42381398144233625 namthat} là, 10 ^{42381398144233625} 10 ^{10 16} .

Lưu ý rằng M không phải là một yếu tố quan trọng trong M (10 ^M ), thứ tự độ lớn của kết quả của mỗi lần lặp, sau đó, theo một mô hình đơn giản hóa của phép chia:

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

Nguồn 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

Đây là nỗ lực sửa đổi của tôi:

{⍞←⎕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

Chương trình 100 char / byte *, chạy trên phần cứng hiện tại (sử dụng một lượng bộ nhớ không đáng kể và các biến int 32 bit thông thường) mặc dù sẽ mất rất nhiều thời gian để hoàn thành.

Bạn thực sự có thể chạy nó trên một trình thông dịch APL và nó sẽ bắt đầu in các chữ số. Nếu được phép hoàn thành, nó sẽ in một số có 10 × 123456789 ⁴⁴ chữ số.

Do đó tỷ số là 10 ^{10 × 123456789 44} /100 ³ ≈ 10 ^{10 353} ≈ 10 ↑↑ 3,406161

Giải trình

• ⎕D là một chuỗi hằng được xác định trước bằng '0123456789'
• n←⍎⎕Dđịnh nghĩa n là số được biểu thị bằng chuỗi đó: 123456789 (là <2 ³¹ và do đó có thể được sử dụng làm biến điều khiển vòng lặp)
• {⍞←⎕D} sẽ in 10 chữ số thành đầu ra tiêu chuẩn, không có dòng mới
• {⍞←⎕D}⍣nsẽ thực hiện nó n lần ( ⍣là "toán tử năng lượng": không phải *, /, cũng không ^, vì đó không phải là phép toán, nó là một dạng vòng lặp)
• {⍞←n}⍣n⍣nsẽ lặp lại thao tác trước đó n lần, do đó in 10 chữ số n ² lần
• {⍞←n}⍣n⍣n⍣nsẽ làm điều đó n ³ lần
• Tôi có thể phù hợp với 44 ⍣ntrong đó, vì vậy nó in n chuỗi ⁴⁴ lần '0123456789'.

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
^{*: APL có thể được viết ở riêng (di sản) charset byte đơn của nó mà các bản đồ ký tự APL đến trên 128 giá trị byte. Do đó, với mục đích ghi điểm, một chương trình gồm các ký tự N chỉ sử dụng các ký tự ASCII và các ký hiệu APL có thể được coi là dài N byte.}

Haskell, điểm: (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

Chương trình này chính xác là 100 byte mã Haskell thuần túy. Nó sẽ in số Ackermann thứ tư, cuối cùng tiêu thụ tất cả năng lượng có sẵn, vật chất và thời gian của vũ trụ và xa hơn nữa trong quá trình này (như vậy, hơi vượt quá giới hạn mềm 5 giây).

Python, 2 ↑↑ 11/830584 10 ↑↑ 8.632971 (Ký hiệu mũi tên lên)

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

Có lẽ không có máy tính nào có đủ bộ nhớ để chạy thành công, nhưng đó không thực sự là lỗi của chương trình. Với các yêu cầu hệ thống tối thiểu thỏa mãn, nó hoạt động.

Vâng, điều này đang làm thay đổi bit trên các giá trị boolean. Truebị ép buộc 1trong bối cảnh này. Python có số nguyên chiều dài tùy ý.

GolfScript 3.673e + 374

'~'(.`*

Tôi nghĩ rằng *nó được cho phép vì nó chỉ ra sự lặp lại chuỗi, không nhân.

Giải thích: '~'(sẽ để lại 126 (giá trị ASCII của "~") trên ngăn xếp. Sau đó sao chép số, chuyển đổi nó thành một chuỗi và lặp lại chuỗi 126 lần. Điều này cho 126126126126...đó là khoảng 1.26 e+377. Giải pháp là 7 ký tự, vì vậy chia 7^3cho, cho số điểm xấp xỉ3.673e+374

Ruby, xác suất vô hạn, 54 ký tự

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

x được khởi tạo thành 97. Sau đó, chúng tôi lặp lại quy trình sau: Tạo x số ngẫu nhiên trong khoảng từ 0 đến 1. Nếu tất cả đều giống nhau, sau đó chấm dứt và in x. Nếu không, nhân đôi x và lặp lại. Vì các số ngẫu nhiên của Ruby có 17 chữ số chính xác, tỷ lệ chấm dứt ở bất kỳ bước nào là 1 trong (10e17) ^ x. Do đó, xác suất chấm dứt trong n bước là tổng của x = 1 đến n của (1 / 10e17) ^ (2 ^ n), hội tụ đến 1 / 10e34. Điều này có nghĩa là đối với bất kỳ số nào, dù lớn đến đâu, rất khó có khả năng chương trình này tạo ra một số nhỏ hơn.

Tất nhiên, bây giờ, câu hỏi triết học là liệu một chương trình có ít hơn 1 trong 10 ^ 34 cơ hội chấm dứt bởi bước n cho bất kỳ n nào có thể được nói là chấm dứt. Nếu chúng ta giả sử không chỉ thời gian và sức mạnh vô hạn, mà chương trình còn được cung cấp khả năng chạy với tốc độ tăng dần với tốc độ vượt quá tốc độ xác suất kết thúc giảm, thì thực tế chúng ta có thể làm cho xác suất chấm dứt theo thời gian t tùy ý gần bằng 1.

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

Điều này được chuyển thể một cách đáng xấu hổ từ một câu trả lời khác của @Howard và kết hợp các đề xuất của @Peter Taylor.

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

Hiểu biết của tôi về GolfScript còn hạn chế, nhưng tôi tin rằng *và các ^toán tử ở trên không phải là toán tử số học bị OP cấm.

(Tôi sẽ vui vẻ xóa cái này nếu @Howard muốn gửi phiên bản của chính anh ta, điều này chắc chắn sẽ vượt trội hơn phiên bản này.)

Chương trình này tính một số xấp xỉ f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126)))))) ))) - một phép lặp chín lần của f _{ε 0} - trong đó f _{ε 0} là hàm trong hệ thống phân cấp phát triển nhanh , tăng trưởng với tốc độ gần bằng với hàm Goodstein. (f _{ε 0}phát triển quá nhanh mà tốc độ tăng trưởng của n Friedman (k) chức năng và k lần Conway xích mũi tên hầu như không đáng kể thậm chí so với chỉ một tổ chức phi lặp đơn f _{ε 0} .)

dc, 100 ký tự

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

Cho đủ thời gian và bộ nhớ, điều này sẽ tính toán một con số khoảng 15 ¹⁶⁶⁶⁶⁶⁵ 15. Ban đầu tôi đã thực hiện chức năng siêu hoạt động, nhưng nó đòi hỏi quá nhiều ký tự cho thử thách này, vì vậy tôi đã loại bỏ các điều kiện n = 2, b = 0và n >= 3, b = 0điều kiện, biến n = 1, b = 0điều kiện thành n >= 1, b = 0.

Các toán tử số học duy nhất được sử dụng ở đây là phép cộng và phép trừ.

EDIT: như đã hứa trong các bình luận, đây là một sự cố về những gì mã này làm:

[            # 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

Như đã lưu ý, điều này lệch khỏi chức năng siêu hoạt động trong đó các trường hợp cơ sở cho phép nhân và cao hơn được thay thế bằng trường hợp cơ sở để bổ sung. Mã này hoạt động như thể a*0 = a^0 = a↑0 = a↑↑0 ... = a, thay vì chính xác về mặt toán học a*0 = 0và a^0 = a↑0 = a↑↑0 ... = 1. Kết quả là, nó tính toán các giá trị cao hơn một chút so với mức cần thiết, nhưng đó không phải là vấn đề lớn vì chúng tôi đang nhắm đến những con số lớn hơn. :)

EDIT: Tôi chỉ nhận thấy rằng một chữ số trượt vào mã một cách tình cờ, trong macro thực hiện gia số cho n=0. Tôi đã loại bỏ nó bằng cách thay thế nó bằng 'F' (15), có tác dụng phụ là tăng tỷ lệ cho mỗi thao tác tăng thêm 15. Tôi không chắc điều này ảnh hưởng đến kết quả cuối cùng như thế nào, nhưng giờ đây có lẽ lớn hơn nhiều.

Không còn giới hạn về thời gian chạy? Được rồi

Chương trình có cần chạy được trên các máy tính hiện đại không?

Cả hai giải pháp sử dụng một biên dịch 64-bit, do đó longlà một 64-bit số nguyên.

C: lớn hơn 10 ^{(2 64 -1) 2 64} , chính nó lớn hơn 10 ^{10 355393490465494856447} 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 ký tự.

Để làm cho các công thức này dễ dàng hơn, tôi sẽ sử dụng t = 2^64-1 = 18446744073709551615.

mainsẽ gọi fvới một tham số t, sẽ lặp lại tthời gian, mỗi lần in giá trị tvà gọi fvới tham số là t-1.

Tổng số chữ số được in : 20 * t.

Mỗi cuộc gọi đến fvới một tham số t-1sẽ lặp lại tlần, in giá trị tvà gọi f với tham số là t-2.

Tổng số chữ số được in: 20 * (t + t*t)

Tôi đã thử chương trình này bằng cách sử dụng số nguyên 3 bit tương đương (tôi đã đặt i = 8và có cuộc gọi chính f(7)). Nó đạt tuyên bố in 6725600 lần. Đó là công trình ra 7^8 + 7^7 + 7^6 + 7^5 + 7^4 + 7^3 + 7^2 + 7Vì vậy, tôi tin rằng đây là số cuối cùng cho toàn bộ chương trình:

Tổng số chữ số được in: 20 * (t + t*t + t^3 + ... + t^(t-1) + t^t + t^(2^64))

Tôi không chắc cách tính (2 ⁶⁴ -1) ^{2 64} . Tổng kết đó nhỏ hơn (2 ⁶⁴ ) ^{2 64} và tôi cần một lũy thừa hai để thực hiện phép tính này. Do đó, tôi sẽ tính (2 ⁶⁴ ) ^{2 64 -1} . Nó nhỏ hơn kết quả thực, nhưng vì nó có sức mạnh bằng hai, tôi có thể chuyển đổi nó thành sức mạnh 10 để so sánh với các kết quả khác.

Có ai biết cách thực hiện phép tính tổng đó hay cách chuyển đổi (2 ⁶⁴ -1) ^{2 64} thành 10 ⁿ không?

20 * 2 ^ 64 ^ (2 ^ 64-1)
20 * 2 ^ 64 ^ 18446744073709551615
20 * 2 ^ (64 * 18446744073709551615)
20 * 2 ^ 1180591620717411303360
10 * 2 ^ 1180591620717411303361
chia số mũ đó theo log cơ sở 2 của 10 để chuyển cơ sở của số mũ thành lũy thừa 10.
1180591620717411303361 / 3.321928094887362347870319429489390175864831393024580612054756 = 
355393490465494856446
10 * 10 ^ 355393490465494856446
10 ^ 355393490465494856447

Nhưng hãy nhớ, đó là số chữ số được in. Giá trị của số nguyên là 10 được nâng lên sức mạnh đó, vì vậy 10 ^ 10 ^ 355393490465494856447

Chương trình này sẽ có độ sâu ngăn xếp là 2 ^ 64. Đó là 2 ^ 72 byte bộ nhớ chỉ để lưu trữ các bộ đếm vòng lặp. Đó là 4 tỷ Terabyte của bộ đếm vòng lặp. Không đề cập đến những thứ khác sẽ có trong stack cho 2 ^ 64 cấp đệ quy.

Chỉnh sửa: Đã sửa một cặp lỗi chính tả và sử dụng giá trị chính xác hơn cho log2 (10).

Chỉnh sửa 2: Đợi một chút, tôi đã có một vòng lặp mà printf nằm ngoài. Hãy sửa nó đi. Đã thêm khởi tạo i.

Chỉnh sửa 3: Đăng nó, tôi làm hỏng toán trên lần chỉnh sửa trước. Đã sửa.

Cái này sẽ chạy trên các máy tính hiện đại, mặc dù nó sẽ không hoàn thành sớm.

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 Nhân vật.

Điều này sẽ in nghịch đảo bit của 0, 2 ^ 64-1, một lần cho mỗi lần lặp. 2 ^ 64-1 là một số gồm 20 chữ số.

Số chữ số = 20 * (2^64-1)^7= 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187500

Làm tròn độ dài chương trình thành 100 ký tự, Điểm = số in / 1.000.000

Điểm = 10 ^ 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187494

R - 49 41 ký tự mã, 4.03624169270483442 * 10 ^ 5928 10 2.576681348

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

sẽ in ra [sao chép ở đây chỉ là bắt đầu]:

403624169270483442010614603558397222347416148937479386587122217348........

ECMAScript 6 - 10 ^ 3 3/884736

(3 ↑↑↑↑ 3 là G (1) trong đó G (64) là số của Graham)

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)

Đầu ra: 10 ^ 3 3

Gợi ý:

Glà hàm trong đó G (64) là số của Graham. Đầu vào là một số nguyên. Đầu ra là một chuỗi unary được viết bằng 0. Loại bỏ cho ngắn gọn.

Klà hàm mũi tên lên Knuth a ↑ ⁿ b trong đó a ẩn 3. Đầu vào là n, một chuỗi unary và b, một chuỗi unary. Đầu ra là một chuỗi unary.

u là "1".

v là "0000" hoặc G (0)

e là "000".

C

(Với lời xin lỗi đến Darren Stone)

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

n = 2 ^ 64 chữ số (9 ...)

l = 100 ký tự mã

điểm 1e + 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936570 10 ↑↑ 3.2974890744

[Điểm = n ^ 5 / l ^ 3 = (10 ^ (2 ^ 320) -1) / (100 ^ 3) = (10 ^ 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086)

Lưu ý rằng tôi xứng đáng bị đánh đập không thương tiếc cho câu trả lời này, nhưng không thể cưỡng lại. Tôi không khuyên bạn nên hành động như tôi trên stackexchange, vì những lý do rõ ràng. :-P

EDIT: Sẽ còn khó hơn để chống lại sự cám dỗ đi cùng với một cái gì đó như

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

... nhưng tôi cho rằng một quy tắc dự định nhưng không xác định là toàn bộ các chữ số tạo thành số phải được in.

New Ruby: điểm ~ f _{w ^ω2 1} (126 ² 2 ¹²⁶ )

trong đó f _α (n) là hệ thống phân cấp phát triển nhanh.

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

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

Đây *nchỉ là phép nhân chuỗi và mảng, vì vậy chúng sẽ ổn.

Mã bị đánh cắp:

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]}

trong đó b.-b<=>0trả về một số nguyên 1gần 0hơn b.

Giải trình:

Nó in nvào lúc bắt đầu của mỗi cuộc gọi của H.

H[[]]nhân đôi n( nlần), tức là n = n<<n.

H[[0,a,b,c,...,z]]cuộc gọi H[[a,b,c,...,z]]( nlần).

H[[k+1,a,b,c,...,z]]cuộc gọi H[[k]*n+[a,b,c,...,z]]( nlần), ở đâu [k]*n = [k,k,...,k].

H[[-1,a,b,c,...,z]]cuộc gọi H[[n]*n+[a,b,c,...,z]]( nlần).

H[[-(k+1),a,b,c,...,z]]cuộc gọi H[[-k]*n+[a,b,c,...,z]]( nlần).

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

Chương trình của tôi khởi tạo n = 126, sau đó gọi H[-n-1]126 ² 2 ¹²⁶ lần.

Ví dụ:

H[[0]]sẽ gọi H[[]]mà áp dụng n = n<<n( nlần).

H[[0,0]]sẽ gọi H[[0]]( nlần).

H[[1]]sẽ gọi H[[0]*n]( nlần).

H[[-1]]sẽ gọi H[[n]*n]( nlần).

H[[-1,-1]]sẽ gọi H[[n]*n+[-1]]( nlần).

H[[-3]]sẽ gọi H[[-2]*n]( nlần).

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

Xem sửa đổi cho những điều mát mẻ khác.

Haskell - Hàm Ackermann được áp dụng cho kết quả của nó 20 lần - 99 ký tự

Đây là giải pháp haskell tốt nhất tôi có thể đưa ra dựa trên hàm ackermann - bạn có thể nhận thấy một số điểm tương đồng với giải pháp của nm, i = round $ log pi được lấy cảm hứng từ đó và phần còn lại là trùng hợp: D

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

Nó tự chạy hàm ackermann 20 lần, bắt đầu từ một, chuỗi đang

• 1,
• 3,
• 61,
• một (61,61),
• a (a (61,61), a (61,61)) --- chúng ta sẽ gọi đây là ₂ (61) hoặc ₄ (1) ---
• một ₃ (61)
• ...
• một ₁₈ (61) hoặc ₂₀ (1). Tôi nghĩ rằng đây là khoảng g ₁₈ (xem bên dưới).

Về dự toán, wikipedia nói:

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

Từ đó, chúng ta có thể thấy a3 (1) = a (61,61) = 2 ↑ ⁵⁹ 64 + 3, rõ ràng lớn hơn g1 = 3 ⁴ 3, trừ khi 3 khi bắt đầu quan trọng hơn nhiều so với tôi nghĩ. Sau đó, mỗi cấp thực hiện các thao tác sau (loại bỏ các hằng số không đáng kể trong một _n ):

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

Nếu những giá trị này tương đương, thì ₂₀ (1) ~ = g ₁₈ . Thuật ngữ cuối cùng trong một _n , ( _n-1 ) lớn hơn 3, vì vậy nó có khả năng cao hơn g ₁₈ . Tôi sẽ xem liệu tôi có thể biết liệu điều đó có thúc đẩy nó ngay cả một lần lặp và báo cáo lại không.

Mã máy x86 - 100 byte (Được lắp ráp dưới dạng tệp MSDOS .com)

Lưu ý: có thể uốn cong các quy tắc một chút

Chương trình này sẽ tạo ra 2 ^{(65536 * 8 + 32)} số điểm sẽ đặt số điểm ở (10 ^{2 524320} -1) / 1000000

Như một bộ đếm, chương trình này sử dụng toàn bộ ngăn xếp (64kiB) cộng với hai thanh ghi 16 bit

Mã lắp ráp:

8A3E61018CD289166101892663018ED331E4BB3A01438A2627
018827A0300130E4FEC4FEC4FEC410E4FEC400E431C95139CC
75FB31D231C931DBCD3F4175F94275F45941750839D4740D59
4174F85131C939D475F9EBDD8B266301A161018ED0C3535858

Hội,, tổ hợp:

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'

C

Kích thước tệp là 45 byte.

Chương trình là:

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

Và số lượng sản xuất lớn hơn 10 ^ (10 ^ (10 ^ 1.305451600608433)).

Tệp tôi đã chuyển hướng tiêu chuẩn hiện tại là hơn 16 Gb và vẫn đang phát triển.

Chương trình sẽ chấm dứt trong một khoảng thời gian hợp lý nếu tôi có một máy tính tốt hơn.

Điểm của tôi là không thể so sánh với điểm nổi chính xác gấp đôi.

GNU Bash, 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 trên bất kỳ hệ thống hợp lý. SHLVL là một số nguyên dương nhỏ (thường là 1 hoặc 2 tùy thuộc vào việc / bin / sh có bash hay không).

Chỉ 64 bit UNIX:

Điểm: ~ 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];);}

Chúng tôi tạo ra một mảng gồm 258048 số nguyên không dấu. Nó không thể được ký dài vì điều đó làm cho chương trình quá dài. Chúng không được ký bởi vì tôi không muốn sử dụng hành vi không xác định, mã này là C phù hợp (khác với việc không trả về từ main ()) và sẽ biên dịch và chạy trên bất kỳ máy bình thường nào, mặc dù vậy nó sẽ tiếp tục chạy trong một thời gian dài . Kích thước này là lớn nhất chúng ta có thể thể hiện một cách hợp pháp mà không cần sử dụng các ký tự không phải là ascii.

Chúng tôi lặp qua mảng bắt đầu từ phần tử cuối cùng. Chúng tôi in các chữ số của 2^32-1, tăng phần tử và thả vòng lặp nếu phần tử chưa được gói thành 0. Bằng cách này, chúng tôi sẽ lặp lại (2^32 - 1)^254048 = 2^8257536thời gian, in 10 chữ số mỗi lần.

Dưới đây là mã ví dụ cho thấy nguyên tắc trong phạm vi dữ liệu hạn chế hơn:

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

Kết quả là khoảng 10 ^ 10 ^ 2485766 chia cho một triệu mà vẫn còn khoảng 10 ^ 10 ^ 2485766.

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

Điều này mất hơn 5 giây để chạy.

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

Nó lấy và ghép độ dài byte của mỗi tệp trên ổ đĩa hiện tại của bạn. Regex loại bỏ bất kỳ ký tự không chữ số.

Python 3, điểm = 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))

Hàm f là hàm ackermann, mà tôi có đủ không gian để gọi.

Chỉnh sửa: trước đây "other n + 1", vi phạm quy tắc thách thức - danh tiếng cho Nghệ thuật đơn giản đẹp.

Ký tự 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)

tạo 2.718e + 239622337 10 ↑↑ 2.9232195202

Đối với số điểm chỉ hơn một chút so với 2.718e + 239622331 10 ↑↑ 2.9232195197

đó là lớn nhất tôi có thể làm cho nó mà không bị lỗi trình duyệt.

(console.log (a) sẽ hiển thị cho bạn toàn bộ đầu ra)

Đừng chạy những thứ này:

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)

sẽ xuất 2.718 + e121333054704 10 ↑↑ 3.0189898069 (còn gọi là 2.718 * 10 ^ (1.213 * 10 ^ 12) để so sánh với câu trả lời dài hơn:

phiên bản cực đoan hơn, nếu nó không bị sập trình duyệt của bạn: (80 char)

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

sẽ tạo ra một số có cùng kích thước với e * 10 ^ (10 ^ 19) 10 ↑↑ 3.106786869689

Chỉnh sửa: mã cập nhật giải pháp gốc chỉ được tạo 2.718e + 464

Python 3: 98 ký tự, ≈ 10 256

Sử dụng hàm đối số biến:

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

Thực tế, E làm giảm đối số đầu tiên trong khi tăng phần còn lại của các đối số, ngoại trừ việc thay vì đặt -1 trong các đối số, nó sẽ loại bỏ đối số. Vì mỗi chu kỳ đều giảm đối số đầu tiên hoặc giảm số lượng đối số, điều này được đảm bảo chấm dứt. Hàm tăng được sử dụng là int ("% d% d"% (k, k)), cho kết quả giữa k ** 2 + 2 * k và 10 * k ** 2 + k. Mã của tôi không sử dụng ký hiệu * - nhưng không phải là phép nhân. Nó được sử dụng để làm việc với số lượng đối số khác nhau, mà tôi nghĩ nên tuân theo các quy tắc vì điểm rõ ràng của quy tắc là hạn chế các hoạt động cụ thể, chứ không phải các biểu tượng.

Một số ví dụ về cách E lớn nhanh chóng:

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)

Chỉ có hai trong số đó là có thể chạy được trên máy tính của tôi trong một khoảng thời gian hợp lý.

Sau đó, E được gọi bởi E(*range(ord('~')))- có nghĩa là:

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

Tôi không hoàn toàn chắc chắn nó lớn đến mức nào (Tôi đã cố gắng ước chừng nó không có tác dụng) - nhưng rõ ràng là nó ~ thực sự ~ lớn.

Ví dụ, khoảng mười hai chu kỳ, kết quả là: (về mặt kỹ thuật nhiều hơn một chút)

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)

Dự toán kết quả:

Nếu chúng ta xấp xỉ bước tăng dần lambda k: 10 * k**2, hàm có thể được mô tả là

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₁²ⁿ), ... )

Điều có liên quan chúng tôi đang làm ở đây là xây dựng một tòa tháp có sức mạnh mười, vì vậy điểm số cuối cùng có thể xấp xỉ là 10 ↑↑ 256.

Ước tính kết quả tốt hơn (mặc dù một phần):

Điều này sử dụng giống 10 * k**2như các ước tính khác.

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

Theo ước tính trước đó, nó sẽ là:

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

Giá trị này nhỏ hơn đáng kể so với giá trị thực tế vì nó sử dụng a**2thay vì 2**acho 10 và sử dụng a*2thay vì 2**acho b.

C (điểm 10 ^ 20 000 000 000 10 ↑↑ 3.005558275)

• Đầu ra ~ 20 GB
• 41 ký tự (41 ^ 3 có nghĩa là không có gì)

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

Mặc dù rand()đầu ra là xác định vì không có chức năng hạt giống.