Mục tiêu của bạn là in (tới đầu ra tiêu chuẩn) số lượng lớn nhất có thể, chỉ sử dụng mười ký tự mã.

• Bạn có thể sử dụng bất kỳ tính năng nào của ngôn ngữ của mình, ngoại trừ các hàm lũy thừa tích hợp.
  • Tương tự, bạn không được sử dụng ký hiệu khoa học để nhập số. (Như vậy, không 9e+99.)
• Chương trình phải in số mà không có bất kỳ đầu vào nào từ người dùng. Tương tự, không đọc từ các tệp khác, hoặc từ Web, v.v.
• Chương trình của bạn phải tính toán một số duy nhất và in nó. Bạn không thể in một chuỗi, bạn cũng không thể in cùng một chữ số hàng nghìn lần.
• Bạn có thể loại trừ khỏi giới hạn 10 ký tự bất kỳ mã nào cần thiết để in bất cứ thứ gì. Ví dụ: trong Python 2 sử dụng print xcú pháp, bạn có thể sử dụng tối đa 16 ký tự cho chương trình của mình.
• Chương trình phải thực sự thành công trong đầu ra. Nếu phải mất hơn một giờ để chạy trên máy tính nhanh nhất thế giới, điều đó không hợp lệ.
• Sản lượng có thể ở định dạng bất kỳ (do đó bạn có thể in 999, 5e+100vv)
• Vô cực là một khái niệm trừu tượng , không phải là một con số. Vì vậy, nó không phải là một đầu ra hợp lệ.

Ngôn ngữ Wolfram

ack(9!,9!)

ack (9 !, 9!) =

Đầu ra là trong Ký hiệu mũi tên.

Perl,> 1.96835797883262e + 18

time*time

Có thể không phải là câu trả lời lớn nhất ... hôm nay! Nhưng đợi đủ thiên niên kỷ và nó sẽ được!

Để giải quyết một số ý kiến, bằng "đủ milimet", thực tế tôi có nghĩa là khoảng ¹⁰⁰ năm.

Công bằng mà nói, nếu cái chết đóng băng / nhiệt lớn của vũ trụ là vũ trụ sẽ kết thúc như thế nào (ước tính xảy ra ~ 10 ¹⁰⁰ năm), giá trị "cuối cùng" sẽ là ~ 10 ²¹⁴ , ít hơn nhiều so với một số các phản ứng khác (mặc dù, "dao động lượng tử ngẫu nhiên hoặc đường hầm lượng tử có thể tạo ra một Vụ nổ lớn khác trong 10 ^{10 56} năm"). Nếu chúng ta thực hiện một cách tiếp cận lạc quan hơn (ví dụ như một mô hình tuần hoàn hoặc đa vũ trụ), thì thời gian sẽ trôi qua vô tận, và vì thế một ngày nào đó trong vũ trụ, trên một số kiến ​​trúc bit cao, câu trả lời sẽ vượt quá một số khác.

Mặt khác, như đã chỉ ra, timethực sự bị giới hạn bởi kích thước của số nguyên / dài, vì vậy trong thực tế, một cái gì đó như ~0sẽ luôn tạo ra một số lớn hơn time(tức là tối đa timeđược hỗ trợ bởi kiến ​​trúc).

Đây không phải là câu trả lời nghiêm túc nhất, nhưng tôi hy vọng các bạn thích nó!

Sói ≅ 2,003529930 × 10 ¹⁹⁷²⁸

Vâng, đó là một ngôn ngữ! Nó thúc đẩy back-end của trang web Wolfram Alpha nổi tiếng. Đó là ngôn ngữ duy nhất tôi tìm thấy nơi hàm Ackermann được tích hợp và viết tắt dưới 6 ký tự.

Trong tám nhân vật:

$ ack(4,2)

200352993...719156733

Hoặc ≅ 2,003529930 × 10 ¹⁹⁷²⁸

ack(4,3), ack(5,2)v.v ... lớn hơn nhiều, nhưng quá lớn. ack(4,2)có lẽ là số Ackermann lớn nhất có thể được tính toán hoàn toàn trong vòng một giờ.

Số lớn hơn được hiển thị ở dạng biểu tượng, ví dụ:

$ ack(4,3)

2↑²6 - 3 // using Knuth's up-arrow notation

Các quy tắc nói rằng bất kỳ định dạng đầu ra đều được cho phép, vì vậy điều này có thể hợp lệ. Con số này lớn hơn 10 ^{10 19727} , lớn hơn bất kỳ mục nào khác ở đây ngoại trừ giai thừa lặp đi lặp lại.

Tuy nhiên,

$ ack(9,9)

2↑⁷12 - 3

lớn hơn giai thừa lặp đi lặp lại. Số lượng lớn nhất tôi có thể nhận được trong mười ký tự là:

$ ack(99,99)

2↑⁹⁷102 - 3

Điều này cực kỳ lớn, Vũ trụ không đủ lớn để thể hiện một phần đáng kể các chữ số của nó, ngay cả khi bạn lấy các bản ghi số lặp đi lặp lại.

Vỏ Python2, 3.010.301 chữ số

9<<9999999

Tính độ dài: Python sẽ nối "L" vào các số dài này, do đó, nó báo cáo nhiều hơn 1 ký tự so với kết quả có các chữ số.

>>> len(repr( 9<<9999999 ))
3010302

20 chữ số đầu tiên và cuối cùng:

40724177878623601356... ...96980669011241992192

CJam, 2 × 10 ^268,435.457

A28{_*}*K*

Điều này tính b , được định nghĩa như sau:

• a ₀ = 10

• a _n = a _{n - 1} ²

• b = 20 × a ₂₈

$ time cjam <(echo 'A28{_*}*K*') | wc -c
Real    2573.28
User    2638.07
Sys     9.46
268435458

Lý lịch

Điều này tuân theo ý tưởng tương tự như câu trả lời của Claudiu , nhưng nó không dựa trên nó. Tôi đã có một ý tưởng tương tự mà tôi đã đăng chỉ vài phút sau khi anh ấy đăng bài của mình , nhưng tôi đã loại bỏ nó vì nó không đến bất cứ nơi nào gần thời gian giới hạn.

Tuy nhiên, đề xuất của Aditsu là nâng cấp lên Java 8 và ý tưởng của tôi về việc sử dụng quyền hạn 10 cho phép CJam tính toán các con số ngoài tầm với của GolfScript, dường như là do một số lỗi / hạn chế của Ruby's Bignum.

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

A    " Push 10.                                                          ";
28{  " Do the following 28 times:                                        ";
  _* " Duplicate the integer on the stack and multiply it with its copy. ";
}*   "                                                                   ";
K*   " Multiply the result by 20.                                        ";

CJam, ≈ 8.1 × 10 ^1.826.751

KK,{)*_*}/

Mất chưa đầy năm phút trên máy của tôi, vì vậy vẫn còn chỗ để cải thiện.

Điều này tính ₂₀ , được định nghĩa như sau:

• a ₀ = 20

• a _n = (n × a _{n - 1} ) ²

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

KK,   " Push 20 [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ]. ";
{     " For each integer in the array:                                 ";
  )*  " Increment it and compute the its product with the accumulator. ";
  _*  " Multiply the result with itself.                               ";
}/

Python 3, 9 * 2 ^ (7 * 2 ^ 33)> 10 ^ 18,100,795,813

9 * 2 ^ (2 ^ 35)> 10 ^ 10,43,311,894

Chỉnh sửa: Câu trả lời mới của tôi là:

9<<(7<<33)

Câu trả lời cũ, cho hậu thế:

9<<(1<<35)

Mười ký tự chính xác.

Tôi đang in số ở dạng hex và

Bạn có thể loại trừ khỏi giới hạn 10 ký tự bất kỳ mã nào cần thiết để in bất cứ thứ gì. Ví dụ, trong Python 2 sử dụng cú pháp in x, bạn có thể sử dụng tối đa 16 ký tự cho chương trình của mình.

Do đó, mã thực tế của tôi là:

print(hex(9<<(7<<33)))

Bằng chứng là nó chạy trong thời gian được chỉ định và tạo ra một số kích thước được chỉ định:

time python bignum.py > bignumoutput.py

real    10m6.606s
user    1m19.183s
sys    0m59.171s
wc -c bignumoutput.py 
15032385541 bignumoutput.py

Số của tôi> 10 ^ (15032385538 * log (16))> 10 ^ 18100795813

3 chữ số hex ít hơn bản in wc ở trên vì ban đầu 0x9 .

Python 3 là cần thiết bởi vì trong python 2, 7<<33sẽ dài và<< không mất nhiều thời gian làm đầu vào.

Tôi không thể sử dụng 9 << (1 << 36) thay vì:

Traceback (most recent call last):
  File "bignum.py", line 1, in <module>
    print(hex(9<<(1<<36)))
MemoryError

Vì vậy, đây là số lượng lớn nhất có thể của mẫu a<<(b<<cd) có thể in trên máy tính của tôi.

Trong tất cả khả năng, máy nhanh nhất trên thế giới có nhiều bộ nhớ hơn tôi, vì vậy câu trả lời thay thế của tôi là:

9<<(9<<99)

9 * 2 ^ (9 * 2 ^ 99)> 10 ^ (1.7172038461 * 10 ^ 30)

Tuy nhiên, câu trả lời hiện tại của tôi là lớn nhất mà bất kỳ ai đã gửi, vì vậy nó có thể đủ tốt. Ngoài ra, đây là tất cả giả định thay đổi bit là cho phép. Nó xuất hiện, từ các câu trả lời khác sử dụng nó.

Bất kỳ ngôn ngữ nào có tên không đổi đủ ngắn, khoảng 18 chữ số.

99/sin(PI)

Tôi sẽ đăng bài này dưới dạng câu trả lời của PHP nhưng thật đáng buồn là M_PInó chỉ hơi dài một chút! Nhưng PHP mang lại 8,0839634798317E + 17 cho việc này. Về cơ bản, nó lạm dụng sự thiếu chính xác tuyệt đối trong PI: p

Haskell

Không có bất kỳ thủ thuật nào:

main = print -- Necessary to print anything
    $9999*9999 -- 999890001

Có thể cho rằng không tính toán bất cứ điều gì:

main = print
    $floor$1/0 -- 179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216

Thích ứng câu trả lời của Niet :

main = print
    $99/sin pi -- 8.083963479831708e17

Powershell - 1.12947668480335E + 42

99PB*9E9PB

Nhân lên gấp 99 lần Pebibytes 9.000.000.000 Pebibytes.

J ( ((((((((9)!)!)!)!)!)!)!)!)

Vâng, đó là rất nhiều. 10^(10^(10^(10^(10^(10^(10^(10^6.269498812196425)))))))không chính xác lắm

!!!!!!!!9x

K / Kona : 8,977649e261 1.774896e308

*/1.6+!170

• !170 tạo một vectơ số từ 0 đến 169
• 1.6+ thêm một cho mỗi phần tử của vectơ & chuyển đổi thành thực (phạm vi là 1,6 đến 170,6)
• */ nhân từng phần tử của mảng với nhau

Nếu Kona hỗ trợ chính xác quad, tôi có thể làm */9.+!999và nhận được khoảng 1e2584. Đáng buồn thay, nó không và tôi giới hạn chính xác gấp đôi.

phương pháp cũ

*/9.*9+!99

• !99 tạo một vectơ số từ 0 đến 98
• 9+ thêm 9 vào mỗi phần tử của vectơ (hiện tại phạm vi 9 đến 107)
• 9.* nhân mỗi phần tử với 9.0 (hoàn toàn chuyển đổi thành số thực, do đó 81.0 đến 963.0)
• */ nhân từng phần tử của vectơ với nhau

HTML, 9999999999

9999999999

.. đóng đinh nó.

Python - Khác nhau, lên tới 13916486568675240 (cho đến nay)

Không hoàn toàn nghiêm túc nhưng tôi nghĩ nó sẽ rất vui.

print id(len)*99

Trong tất cả những điều tôi đã cố gắng, len hầu hết đều mang lại cho tôi những id lớn.

Mang lại 13916486568675240 (17 chữ số) trên máy tính của tôi và 13842722750490216 (cũng 17 chữ số) trên trang web này . Tôi cho rằng điều này có thể khiến bạn thấp đến 0, nhưng nó cũng có thể cao hơn.

Golf, 1e + 33,554,432

10{.*}25*

Tính toán 10 ^ (2 ^ 25), không sử dụng số mũ, chạy trong 96 giây:

$ time echo "10{.*}25*" | ruby golfscript.rb  > BIG10

real    1m36.733s
user    1m28.101s
sys     0m6.632s
$ wc -c BIG10
 33554434 BIG10
$ head -c 80 BIG10
10000000000000000000000000000000000000000000000000000000000000000000000000000000
$ tail -c 80 BIG10
0000000000000000000000000000000000000000000000000000000000000000000000000000000

Nó có thể tính toán tối đa 9 ^ (2 ^ 9999), nếu chỉ được cung cấp đủ thời gian, nhưng việc tăng số mũ bên trong lên một lần khiến nó mất ~ gấp ba thời gian, do đó giới hạn một giờ sẽ đạt được khá sớm.

Giải thích :

Sử dụng một phiên bản trước đó với cùng một ý tưởng:

8{.*}25*

Phá vỡ nó:

8         # push 8 to the stack
{...}25*  # run the given block 25 times

Ngăn xếp ở đầu mỗi khối bao gồm một số, số hiện tại. Điều này bắt đầu như là 8. Sau đó:

.         # duplicate the top of the stack, stack is now | 8 | 8 |
*         # multiply top two numbers, stack is now       | 64 |

Vì vậy, ngăn xếp, từng bước, trông như thế này:

8
8 8
64
64 64
4096
4096 4096
16777216
16777216 16777216

... vv Viết bằng ký hiệu toán học, tiến trình là:

n=0, 8                     = 8^1  = 8^(2^0)
n=1, 8*8                   = 8^2  = 8^(2^1)
n=2, (8^2)*(8^2) = (8^2)^2 = 8^4  = 8^(2^2)
n=3,               (8^4)^2 = 8^8  = 8^(2^3)
n=4,               (8^8)^2 = 8^16 = 8^(2^4)

wxMaxima ~ 3x10 ^49.948 (hoặc 10 ^{8,565,705,514} )

999*13511!

Đầu ra là

269146071053904674084357808139[49888 digits]000000000000000000000000000000

Không chắc chắn nếu nó khá phù hợp với thông số kỹ thuật (đặc biệt là định dạng đầu ra), nhưng tôi có thể nhấn lớn hơn nữa:

bfloat(99999999!)

Đầu ra là

9.9046265792229937372808210723818b8565705513

Đó là khoảng 10 ^8565705514 đó là đáng kể lớn hơn hầu hết các câu trả lời trên và được tính trong khoảng 2 giây. Các bfloatchức năng cung cấp cho độ chính xác tùy ý .

Haskell, 4950

Người đàn ông, đó không phải là nhiều! 10 ký tự bắt đầu sau ký hiệu đô la.

main=putStr.show$sum[1..99]

Toán học, 2.174188391646043 * 10 ^ 20686623745

$MaxNumber

Mười ký tự chính xác.

Vỏ Python, 649539 999890001

Beats Haskell, không thực sự là một câu trả lời nghiêm túc.

99999*9999

Wolfram Alpha (một trang web được tính là ngôn ngữ)?

9! ! ! ! !

đầu ra

10^(10^(10^(10^(10^(6.27...))))

cảm ơn Cory vì tiền boa mà không gian làm việc cũng như parens.

Befunge-93 (1.853.020.188.851.841)

Vui mừng vì chưa có ai thực hiện Befunge (đó là sở trường của tôi), nhưng thật đáng tiếc tôi không thể tìm thấy bất kỳ mẹo thông minh nào để tăng số lượng.

9:*:*:*:*.

Vậy là 9 ^ 16.

:*

Về cơ bản nhân giá trị ở đầu ngăn xếp với chính nó. Vì vậy, giá trị ở đầu ngăn xếp đi:

9
81
6561
43046721
1853020188851841

và

.

Xuất ra giá trị cuối cùng. Tôi sẽ quan tâm xem có ai có ý tưởng nào tốt hơn không.

Tôi muốn đăng bài này như một bình luận ở trên, nhưng dường như tôi không thể vì tôi là một người mới.

Con trăn

9<<(2<<29)

Tôi muốn có một sự thay đổi bit lớn hơn, nhưng Python dường như muốn toán hạng đúng của một ca làm một số nguyên không dài. Tôi nghĩ rằng điều này gần với tối đa lý thuyết:

9<<(7<<27)

Vấn đề duy nhất với chúng là chúng có thể không thỏa mãn quy tắc 5.

Matlab (1.7977e + 308)

Matlab lưu giá trị của số dấu phẩy động lớn nhất (độ chính xác kép) trong một biến được gọi realmax. Gọi nó trong cửa sổ lệnh (hoặc tại dòng lệnh) in giá trị của nó:

>> realmax

ans =

  1.7977e+308

Con trăn, ca. 1.26e1388

9<<(9<<9L)

Cung cấp:

126026689735396303510997749074166929355794746000200933374690887068497279540873057344588851620847941756785436041299246554387020554314993586209922882758661017328592694996553929727854519472712351667110666886882465827559219102188617052626543482184096111723688960246772278895906137468458526847698371976335253039032584064081316325315024075215490091797774136739726784527496550151562519394683964055278594282441271759517280448036277054137000457520739972045586784011500204742714066662771580606558510783929300569401828194357569630085253502717648498118383356859371345327180116960300442655802073660515692068448059163472438726337412639721611668963365329274524683795898803515844109273846119396045513151325096835254352967440214290024900894106148249792936857620252669314267990625341054382109413982209048217613474462366099211988610838771890047771108303025697073942786800963584597671865634957073868371020540520001351340594968828107972114104065730887195267530118107925564666923847891177478488560095588773415349153603883278280369727904581288187557648454461776700257309873313090202541988023337650601111667962042284633452143391122583377206859791047448706336804001357517229485133041918063698840034398827807588137953763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913947514564759718572657335136386433456038688663246414030999145137634036313038859977295626367160619139475145647597185726573351363864334560386886632464140309991451

Ít nhất Python 3.5.0 (64 bit), hơn 10 ^ 242944768872896860

print("{:x}".format( 9<<(7<<60) ))

Trong một thế giới lý tưởng, điều này sẽ xảy ra 9<<(1<<63)-1, nhưng không có đủ byte cho điều đó. Con số này lớn đến mức nó đòi hỏi gần 1 EiB bộ nhớ để giữ nó, nhiều hơn một chút so với tôi có trên máy tính của mình. May mắn thay, bạn chỉ cần sử dụng khoảng 0,2% dung lượng lưu trữ của thế giới dưới dạng trao đổi để giữ nó. Giá trị trong nhị phân được 1001theo sau bởi các số không 8070450532247928832.

Nếu Python xuất hiện cho các máy 128 bit, mức tối đa sẽ là 9<<(9<<99) , đòi hỏi ít hơn 1 MiYiB bộ nhớ. Điều này là tốt, bởi vì bạn có đủ không gian địa chỉ còn lại để lưu trữ trình thông dịch Python và hệ điều hành.

Đàn con , 9.670457478596419e + 147 (không cạnh tranh)

****"///**

Không cạnh tranh vì Cubix mới hơn thử thách này. Bạn có thể kiểm tra nó trực tuyến tại đây , nhưng lưu ý rằng nó không thực sự in số; bạn sẽ phải tạm dừng chương trình sau khi hai *giây cuối được chạy để xem giá trị trên ngăn xếp.

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

Cubix là một esolang 2 chiều trong đó mã được quấn quanh một khối. Mã này hoàn toàn tương đương với mạng khối sau đây, trong đó .không có op:

    * *
    * *
" / / / * * . .
. . . . . . . .
    . .
    . .

Sau đó, mã được chạy, với con trỏ lệnh (IP) bắt đầu ở góc trên cùng bên trái của mặt ngoài cùng bên trái, mặt phải. "bật chế độ chuỗi, trong đó tất cả các ký tự gặp phải cho đến lần tiếp theo "đẩy mã char của chúng vào ngăn xếp. IP bao bọc toàn bộ mã, đẩy ba /s (47), hai *s (42) và hai. s (46) vào ngăn xếp, trước khi thoát khỏi chế độ chuỗi.

Đây là nơi nó trở nên thú vị. Chiếc gương đầu tiên /phản ánh IP để nó hướng lên; sau đó nó xoay quanh khối lập phương, đánh những ký tự này:

           
    * *
  /     *      
  .     .      
    . .

Ba *s nhân hai mục trên cùng trên ngăn xếp. Bây giờ, không giống như hầu hết các ngôn ngữ dựa trên ngăn xếp nơi các toán tử số học bật các đối số của chúng, Cubix để lại các giá trị trước đó trên ngăn xếp. Vì vậy, điều đó có nghĩa là tính toán này46*46 = 2116, 46*2116 = 97336, 2116*97336 = 205962976 .

Khi IP đạt đến /một lần nữa, nó được chuyển sang phải. Sau đó, nó chạm gương tiếp theo và đi theo con đường này:

    *  
    *  
    /         .
    .         .
    .  
    .  

Hai dấu sao nhân hai mục trên cùng một lần nữa. Sau đó, gương điều khiển IP lại một lần nữa và gương thứ ba lặp lại quy trình một lần nữa:

      *
      *
      /     .  
      .     .  
      .
      .

Cuối cùng, IP rời khỏi phần gương hướng về phía đông. Hai dấu sao cuối cùng nhân hai lần nữa, để lại kết quả là 9.670457478596419e + 147 trên ngăn xếp. Điều này có thể được in O, nhưng không có cách nào dễ dàng để làm điều đó vì thực tế mọi vị trí trên khối đều đã được sử dụng.

Scala, 2 ⁶³ -1

Nghèo, nghèo Scala. Mất ít nhất 8 ký tự để có được mộtBigInt giá trị, không đủ chỗ để thực sự làm cho nó lớn.

Nhưng chỉ với 7 ký tự (được tính), chúng ta có thể in số dương lớn nhất có thể Long:

print(-1L>>>1)

Brainf ** k 256 - 2147483647

>+[<+>+]<.

_{Nếu bạn bỏ qua thực tế là hầu hết các trình biên dịch & trình thông dịch đều xuất dữ liệu tương đương với ascii (có thể là chính nó;))} , điều này sẽ trả về giá trị tối đa của kiểu dữ liệu của trình thông dịch / trình biên dịch.

Trên một số hệ thống, đây chỉ là 256, mặc dù trên một số (ví dụ của tôi), đây là giá trị tối đa của số nguyên 32 bit, tức là 2 147 483 647.

Biên tập:

-.

Sẽ in cùng một thứ trong ít ký tự hơn

Perl, không cạnh tranh

Tôi đang sử dụng điều này để làm nổi bật một góc nhỏ của perl.

Perl không thể thực sự cạnh tranh trên cái này bởi vì nó không có bignums dựng sẵn (tất nhiên bạn có thể tải một thư viện bignum).

Nhưng những gì mọi người biết không hoàn toàn đúng. Một chức năng cốt lõi thực sự có thể xử lý số lượng lớn.

Các packđịnh dạng wthực sự có thể chuyển đổi bất kỳ số tự nhiên kích thước giữa cơ sở 10và cơ sở 128. Tuy nhiên, số nguyên 128 cơ sở được biểu diễn dưới dạng byte chuỗi. Chuỗi bit xxxxxxxyyyyyyyzzzzzzztrở thành các byte: 1xxxxxxx 1yyyyyyy 0zzzzzzz(mỗi byte bắt đầu bằng 1 ngoại trừ byte cuối cùng). Và bạn có thể chuyển đổi một chuỗi như vậy sang cơ sở 10 với giải nén. Vì vậy, bạn có thể viết mã như:

unpack w,~A x 4**4 .A

cung cấp cho:

17440148077784539048602210552864286760481312243331966651657423831944908597692986131110771184688683631223604950868378426010091037391551287028966465246275171764867964902846884403624214574779667949236313638077978794791039372380746518407204456880869394123452212674801443116750853569815557532270825838757922217314748231826241930826238846175896997055564919425918463307658663171965135057749089077388054942032051553760309927468850847772989423963904144861205988704398838295854027686335454023567793114837657233481456867922127891951274737700618284015425

Bạn có thể thay thế 4**4bằng các giá trị lớn hơn cho đến khi bạn cảm thấy mất quá nhiều thời gian hoặc sử dụng quá nhiều bộ nhớ.

Thật không may, đây là quá dài cho giới hạn của thử thách này và bạn có thể lập luận rằng kết quả cơ sở 10 được chuyển đổi thành một chuỗi trước khi nó trở thành kết quả để biểu thức không thực sự tạo ra một số. Nhưng bên trong perl thực sự làm số học cần thiết để chuyển đổi đầu vào thành cơ sở 10 mà tôi luôn coi là khá gọn gàng.

TI-36 (không phải 84, 36), 10 byte, xấp xỉ. 9,999985426E99

Máy tính cũ hơn cũng có thể được lập trình ở một mức độ nào đó;)

69!58.4376

Điều này rất gần với phạm vi tối đa mà máy tính TI có thể hiển thị:-1E100<x<1E100

Perl 6 , 456,574 chữ số

[*] 1..ↈ

Không có TIO vì phải mất 2 phút để chạy.