เป้าหมายของคุณคือพิมพ์จำนวนสูงสุดที่เป็นไปได้โดยใช้รหัสเพียงสิบตัวอักษร

• คุณสามารถใช้คุณสมบัติใด ๆ ของภาษาของคุณยกเว้นฟังก์ชั่นการยกกำลังในตัว
  • ในทำนองเดียวกันคุณไม่สามารถใช้สัญลักษณ์ทางวิทยาศาสตร์เพื่อป้อนตัวเลขได้ (เช่นนั้นไม่มี9e+99)
• โปรแกรมจะต้องพิมพ์หมายเลขโดยไม่ต้องป้อนข้อมูลใด ๆ จากผู้ใช้ ในทำนองเดียวกันไม่มีการอ่านจากไฟล์อื่น ๆ หรือจากเว็บและอื่น ๆ
• โปรแกรมของคุณจะต้องคำนวณหมายเลขเดียวและพิมพ์ คุณไม่สามารถพิมพ์สตริงและไม่สามารถพิมพ์ตัวเลขหลักพันเท่ากันได้
• คุณสามารถยกเว้นรหัสได้ไม่เกิน 10 ตัวที่จำเป็นสำหรับการพิมพ์อะไรก็ได้ ตัวอย่างเช่นใน Python 2 ซึ่งใช้print xไวยากรณ์คุณสามารถใช้อักขระได้สูงสุด 16 ตัวสำหรับโปรแกรมของคุณ
• โปรแกรมต้องประสบความสำเร็จในผลลัพธ์จริง ๆ หากใช้เวลานานกว่าหนึ่งชั่วโมงในการทำงานบนคอมพิวเตอร์ที่เร็วที่สุดในโลกมันไม่ถูกต้อง
• การส่งออกอาจจะอยู่ในรูปแบบใด ๆ (เพื่อให้คุณสามารถพิมพ์999, 5e+100ฯลฯ )
• อินฟินิตี้เป็นแนวคิดที่เป็นนามธรรมไม่ใช่ตัวเลข ดังนั้นจึงไม่ใช่เอาต์พุตที่ถูกต้อง

ภาษา Wolfram

ack(9!,9!)

ack (9!, 9!) =

เอาต์พุตอยู่ในเครื่องหมายลูกศร

Perl,> 1.96835797883262e + 18

time*time

อาจไม่ใช่คำตอบที่ใหญ่ที่สุด ... วันนี้! แต่รอเป็นพันปีที่เพียงพอและมันจะเป็น!

ในการพูดถึงความคิดเห็นบางส่วนโดย "millenia เพียงพอ" ในความเป็นจริงฉันหมายถึง^{ns 100}ปี

หากว่าการแช่แข็ง / การเสียความร้อนครั้งใหญ่ของเอกภพเป็นวิธีการที่เอกภพจะสิ้นสุดลง (ประมาณว่าจะเกิดขึ้นประมาณ 10 ¹⁰⁰ปี) ค่า "สุดท้าย" จะเป็น 10 ~ ²¹⁴ซึ่งน้อยกว่าบางส่วน คำตอบอื่น ๆ (แม้ว่า "ความผันผวนของควอนตัมแบบสุ่มหรือการขุดอุโมงค์ควอนตัมสามารถสร้างบิ๊กแบงอีก 10 ^{10 56}ปี") ถ้าเราใช้วิธีการมองโลกในแง่ดีมากขึ้น (เช่นแบบจำลองวงจรหรือแบบลิขสิทธิ์) เวลาจะดำเนินต่อไปอย่างไม่ จำกัด ดังนั้นวันหนึ่งในจักรวาลบางแห่งในสถาปัตยกรรมระดับสูงบางคำตอบอาจจะเกินคำตอบของคนอื่น

ในทางตรงกันข้ามตามที่ระบุtimeจริง ๆ แล้วถูก จำกัด ด้วยขนาดของจำนวนเต็ม / ยาวดังนั้นในความเป็นจริงบางสิ่งบางอย่างเช่น~0มักจะสร้างจำนวนมากขึ้นกว่าtime(เช่นสูงสุดที่timeได้รับการสนับสนุนโดยสถาปัตยกรรม)

นี่ไม่ใช่คำตอบที่จริงจังที่สุด แต่ฉันหวังว่าพวกคุณจะสนุกไปกับมัน!

วุลแฟรม≅ 2.003529930 × 10 ¹⁹⁷²⁸

ใช่มันเป็นภาษา! มันขับเคลื่อนส่วนหลังของเว็บไซต์ Wolfram Alpha ยอดนิยม มันเป็นภาษาเดียวที่ฉันพบว่ามีฟังก์ชันในตัวของ Ackermann และมีตัวย่อน้อยกว่า 6 ตัวอักษร

ในแปดตัวอักษร:

$ ack(4,2)

200352993...719156733

หรือ≅ 2.003529930 × 10 ¹⁹⁷²⁸

ack(4,3), ack(5,2)ฯลฯ มีขนาดใหญ่มาก แต่มีขนาดใหญ่เกินไป ack(4,2)น่าจะเป็นจำนวน Ackermann ที่ใหญ่ที่สุดกว่าที่สามารถคำนวณได้อย่างสมบูรณ์ในภายใต้ชั่วโมง

ตัวเลขขนาดใหญ่จะแสดงผลในรูปแบบสัญลักษณ์เช่น:

$ ack(4,3)

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

กฎบอกว่าอนุญาตรูปแบบเอาต์พุตใด ๆ ดังนั้นสิ่งนี้อาจใช้ได้ นี่คือมากกว่า 10 ^{10 19727}ซึ่งใหญ่กว่ารายการอื่น ๆ ที่นี่ยกเว้นสำหรับแฟกทอเรียลซ้ำ

อย่างไรก็ตาม

$ ack(9,9)

2↑⁷12 - 3

มีขนาดใหญ่กว่าแฟกทอเรียลที่ทำซ้ำ จำนวนที่มากที่สุดที่ฉันจะได้รับในสิบตัวละครคือ:

$ ack(99,99)

2↑⁹⁷102 - 3

นี่เป็นเรื่องใหญ่อย่างบ้าคลั่งจักรวาลไม่ใหญ่พอที่จะแสดงตัวเลขหลักของมันแม้ว่าคุณจะเอาบันทึกซ้ำ ๆ

Python2 shell, 3,010,301 ดิจิต

9<<9999999

การคำนวณความยาว: Python จะต่อท้าย "L" กับตัวเลขที่ยาวเหล่านี้ดังนั้นมันจึงรายงาน 1 ตัวอักษรมากกว่าผลที่ได้คือตัวเลข

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

ตัวเลข 20 หลักแรกและสุดท้าย:

40724177878623601356... ...96980669011241992192

CJam, 2 × 10 ^268,435,457

A28{_*}*K*

สิ่งนี้คำนวณbนิยามดังนี้:

• 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

พื้นหลัง

สิ่งนี้เป็นไปตามแนวคิดเดียวกันกับคำตอบของ Claudiuแต่มันไม่ได้ขึ้นอยู่กับมัน ฉันมีความคิดที่คล้ายกันซึ่งฉันโพสต์เพียงไม่กี่นาทีหลังจากที่เขาโพสต์เขาแต่ฉันทิ้งเพราะมันไม่ได้มาที่ใดก็ได้ใกล้เวลาที่กำหนด

อย่างไรก็ตามข้อเสนอแนะของ aditsu ในการอัพเกรดเป็น Java 8 และความคิดของฉันในการใช้พาวเวอร์ 10 อนุญาตให้ CJam คำนวณตัวเลขที่เกินขอบเขตของ GolfScript ซึ่งดูเหมือนว่าจะเกิดจากข้อผิดพลาด / ข้อ จำกัด บางอย่างของ Ruby Bignum

มันทำงานอย่างไร

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,{)*_*}/

ใช้เวลาน้อยกว่าห้านาทีบนเครื่องของฉันดังนั้นยังมีพื้นที่สำหรับการปรับปรุง

สิ่งนี้คำนวณ₂₀ซึ่งกำหนดดังนี้:

• ₀ = 20

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

มันทำงานอย่างไร

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,343,311,894

แก้ไข: คำตอบใหม่ของฉันคือ:

9<<(7<<33)

คำตอบเก่าสำหรับลูกหลาน:

9<<(1<<35)

สิบตัวอักษรอย่างแน่นอน

ฉันกำลังพิมพ์ตัวเลขเป็นฐานสิบหกและ

คุณสามารถยกเว้นรหัสได้ไม่เกิน 10 ตัวที่จำเป็นสำหรับการพิมพ์อะไรก็ได้ ตัวอย่างเช่นใน Python 2 ซึ่งใช้ไวยากรณ์ print x คุณสามารถใช้อักขระได้สูงสุด 16 ตัวสำหรับโปรแกรมของคุณ

ดังนั้นรหัสจริงของฉันคือ:

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

พิสูจน์ว่ามันทำงานในเวลาที่กำหนดและสร้างจำนวนขนาดที่ระบุ:

time python bignum.py > bignumoutput.py

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

หมายเลขของฉัน> 10 ^ (15032385538 * บันทึก (16))> 10 ^ 18100795813

3 เลขฐานสิบหกน้อยกว่างานพิมพ์ wc 0x9ข้างต้นเพราะการเริ่มต้น

Python 3 เป็นสิ่งจำเป็นเพราะใน python 2 7<<33จะยาวและ<<ไม่ใช้เวลานานเหมือนอินพุต

ฉันไม่สามารถใช้ 9 << (1 << 36) แทนเพราะ:

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

ดังนั้นนี่เป็นจำนวนที่มากที่สุดของแบบฟอร์มที่a<<(b<<cd)พิมพ์บนคอมพิวเตอร์ของฉัน

ในทุกโอกาสเครื่องที่เร็วที่สุดในโลกมีหน่วยความจำมากกว่าที่ฉันทำดังนั้นคำตอบสำรองของฉันคือ:

9<<(9<<99)

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

อย่างไรก็ตามคำตอบปัจจุบันของฉันคือใครก็ได้ที่ใหญ่ที่สุดที่ส่งมาดังนั้นจึงอาจดีพอ นอกจากนี้ทั้งหมดนี้ถือว่าการเลื่อนบิตเป็นสิ่งที่ทำได้ ดูเหมือนว่าจะเป็นจากคำตอบอื่น ๆ ที่ใช้มัน

ภาษาใด ๆ ที่มีชื่อคงที่สั้นพอเพียงประมาณ 18 หลัก

99/sin(PI)

ฉันจะโพสต์สิ่งนี้เป็นคำตอบ PHP แต่น่าเศร้าที่M_PIทำให้มันยาวเกินไป! แต่ PHP ให้ผลลัพธ์ 8.0839634798317E + 17 สำหรับสิ่งนี้ โดยพื้นฐานแล้วจะเป็นการละเมิดการขาดความแม่นยำที่แน่นอนใน PI: p

Haskell

ไม่มีเทคนิคใด ๆ :

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

เนื้อหาโดยไม่ต้องคำนวณอะไร:

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

ปรับคำตอบของ Niet :

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

Powershell - 1.12947668480335E + 42

99PB*9E9PB

ทวีคูณ 99 Pebibytes คูณ 9,000,000,000 Pebibytes

เจ ( ((((((((9)!)!)!)!)!)!)!)!)

ใช่นั่นเป็นจำนวนมาก 10^(10^(10^(10^(10^(10^(10^(10^6.269498812196425)))))))จะไม่แม่นยำมาก

!!!!!!!!9x

K / Kona : 8.977649e261 1.774896e308

*/1.6+!170

• !170 สร้างเวกเตอร์ของตัวเลขตั้งแต่ 0 ถึง 169
• 1.6+ เพิ่มหนึ่งองค์ประกอบให้กับแต่ละองค์ประกอบของเวกเตอร์ & แปลงเป็นเรียล (ช่วงคือ 1.6 ถึง 170.6)
• */ คูณแต่ละองค์ประกอบของอาร์เรย์ด้วยกัน

หาก Kona สนับสนุนความแม่นยำแบบ Quad ฉันสามารถทำได้*/9.+!999และได้รับประมาณ 1e2584 น่าเศร้าที่มันไม่ได้และฉันถูก จำกัด ให้มีความแม่นยำเป็นสองเท่า

วิธีการเก่า

*/9.*9+!99

• !99 สร้างเวกเตอร์ของตัวเลขตั้งแต่ 0 ถึง 98
• 9+ เพิ่ม 9 องค์ประกอบของเวกเตอร์ (ตอนนี้ช่วง 9 ถึง 107)
• 9.* คูณแต่ละองค์ประกอบด้วย 9.0 (โดยปริยายแปลงเป็น reals ดังนั้น 81.0 ถึง 963.0)
• */ คูณแต่ละองค์ประกอบของเวกเตอร์ด้วยกัน

HTML, 9999999999

9999999999

.. ถูกจับมัน

Python - แตกต่างกันมากถึง 13916486568675240 (จนถึงตอนนี้)

ไม่จริงจังเลย แต่ฉันคิดว่ามันคงจะสนุกดี

print id(len)*99

จากทุกสิ่งที่ฉันพยายามlenคือทำให้ฉันได้รับรหัสที่มีขนาดใหญ่อย่างสม่ำเสมอ

ให้ผลเป็น 13916486568675240 (17 หลัก) บนคอมพิวเตอร์ของฉันและ 13842722750490216 (รวมทั้ง 17 หลัก) ในเว็บไซต์นี้ ฉันคิดว่ามันเป็นไปได้สำหรับเรื่องนี้ที่จะให้คุณเป็นต่ำเป็น 0 แต่ก็อาจจะสูงขึ้น

Golfscript, 1e + 33,554,432

10{.*}25*

คำนวณ10 ^ (2 ^ 25)โดยไม่ใช้เลขชี้กำลังเรียกใช้ใน 96 วินาที:

$ 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

มันสามารถคำนวณได้ถึง9 ^ (2 ^ 9999)ถ้าให้เวลาเพียงพอ แต่การเพิ่มเลขชี้กำลังภายในโดยการเพิ่มขึ้นทำให้ใช้เวลา ~ สามเท่าดังนั้นขีด จำกัด หนึ่งชั่วโมงจะมาถึงในไม่ช้า

คำอธิบาย :

การใช้เวอร์ชันก่อนหน้าด้วยแนวคิดเดียวกัน:

8{.*}25*

ทำลายมันลง:

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

สแต็คที่จุดเริ่มต้นของแต่ละบล็อกประกอบด้วยหมายเลขหนึ่งหมายเลขปัจจุบัน 8นี้เริ่มต้นออกเป็น แล้ว:

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

สแต็กทีละขั้นตอนมีลักษณะดังนี้:

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

... ฯลฯ เขียนในรูปแบบทางคณิตศาสตร์ความก้าวหน้าคือ:

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 (หรือ 10 ^{8,565,705,514} )

999*13511!

ผลผลิตคือ

269146071053904674084357808139[49888 digits]000000000000000000000000000000

ไม่แน่ใจว่ามันเหมาะกับสเป็คหรือไม่ (โดยเฉพาะรูปแบบเอาต์พุต) แต่ฉันสามารถตีให้ใหญ่ขึ้นได้:

bfloat(99999999!)

ผลผลิตคือ

9.9046265792229937372808210723818b8565705513

นั่นคือประมาณ 10 ^{8,565,705,514}ซึ่งใหญ่กว่าคำตอบส่วนใหญ่อย่างมีนัยสำคัญและถูกคำนวณในเวลาประมาณ 2 วินาที bfloatฟังก์ชั่นช่วยให้ความแม่นยำโดยพลการ

Haskell, 4950

เอ่อชายนั่นไม่มาก! 10 ตัวอักษรเริ่มต้นหลังจากเครื่องหมายดอลลาร์

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

Mathematica, 2.174188391646043 * 10 ^ 20686623745

$MaxNumber

สิบตัวอักษรอย่างแน่นอน

Python shell, 649539 999890001

Beats Haskell ไม่ใช่คำตอบที่จริงจังจริงๆ

99999*9999

Wolfram Alpha (เว็บไซต์นับเป็นภาษา) หรือไม่

9! ! ! ! !

เอาท์พุท

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

ขอบคุณ Cory สำหรับเคล็ดลับที่พื้นที่ทำงานเช่นเดียวกับการล้อเลียน

Befunge-93 (1,853,020,188,851,841)

ดีใจที่ไม่มีใครทำ Befunge เลย (มันเป็นช่องของฉัน) แต่ก็เถอะฉันไม่สามารถหาเคล็ดลับที่ฉลาดเพื่อเพิ่มจำนวนได้

9:*:*:*:*.

มันคือ 9 ^ 16

:*

โดยทั่วไปจะคูณค่าที่ด้านบนของสแต็กด้วยตัวเอง ดังนั้นค่าที่ด้านบนของสแต็คจะเป็นดังนี้:

9
81
6561
43046721
1853020188851841

และ

.

ส่งออกค่าสุดท้าย ฉันสนใจที่จะดูว่าใครมีแนวคิดที่ดีกว่านี้หรือไม่

ฉันต้องการโพสต์สิ่งนี้เป็นความคิดเห็นด้านบน แต่เห็นได้ชัดว่าฉันทำไม่ได้เนื่องจากฉันเป็นคนไม่มีอะไร

งูหลาม:

9<<(2<<29)

ฉันจะไปกับการเปลี่ยนแปลงบิตที่มีขนาดใหญ่ขึ้น แต่ Python ดูเหมือนว่าต้องการตัวถูกดำเนินการด้านขวาของการเปลี่ยนแปลงที่จะเป็นจำนวนเต็มไม่นาน ฉันคิดว่านี่จะเข้าใกล้ค่าสูงสุดตามทฤษฎี:

9<<(7<<27)

ปัญหาเดียวของสิ่งเหล่านี้คือพวกเขาอาจไม่ปฏิบัติตามกฎ 5

Matlab (1.7977e + 308)

Matlab เก็บค่าที่ใหญ่ที่สุด (ความแม่นยำสอง) realmaxจำนวนจุดลอยตัวในตัวแปรที่เรียกว่า เรียกใช้งานในหน้าต่างคำสั่ง (หรือที่บรรทัดคำสั่ง) พิมพ์ค่า:

>> realmax

ans =

  1.7977e+308

Python, แคลิฟอร์เนีย 1.26e1388

9<<(9<<9L)

ให้:

126026689735396303510997749074166929355794746000200933374690887068497279540873057344588851620847941756785436041299246554387020554314993586209922882758661017328592694996553929727854519472712351667110666886882465827559219102188617052626543482184096111723688960246772278895906137468458526847698371976335253039032584064081316325315024075215490091797774136739726784527496550151562519394683964055278594282441271759517280448036277054137000457520739972045586784011500204742714066662771580606558510783929300569401828194357569630085253502717648498118383356859371345327180116960300442655802073660515692068448059163472438726337412639721611668963365329274524683795898803515844109273846119396045513151325096835254352967440214290024900894106148249792936857620252669314267990625341054382109413982209048217613474462366099211988610838771890047771108303025697073942786800963584597671865634957073868371020540520001351340594968828107972114104065730887195267530118107925564666923847891177478488560095588773415349153603883278280369727904581288187557648454461776700257309873313090202541988023337650601111667962042284633452143391122583377206859791047448706336804001357517229485133041918063698840034398827807588137953763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L

อย่างน้อย Python 3.5.0 (64- บิต) มากกว่า 10 ^ 242944768872896860

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

ในโลกอุดมคตินี่จะเป็น9<<(1<<63)-1เช่นนั้น แต่มีไม่เพียงพอสำหรับไบต์ ตัวเลขนี้ใหญ่มากที่ต้องใช้หน่วยความจำเกือบ 1 EiB เพื่อเก็บไว้ซึ่งมากกว่าที่ฉันมีในคอมพิวเตอร์เล็กน้อย โชคดีที่คุณจำเป็นต้องใช้พื้นที่เก็บข้อมูลประมาณ 0.2% ของโลกเพื่อสลับไปมา ค่าในไบนารีจะ1001ตามด้วยศูนย์ 8070450532247928832

ถ้า Python ออกมาสำหรับเครื่องที่มีขนาด 128 บิตสูงสุดจะเป็น9<<(9<<99)ซึ่งต้องใช้หน่วยความจำน้อยกว่า 1 MiYiB นี่เป็นสิ่งที่ดีเพราะคุณมีพื้นที่เหลือที่สามารถกำหนดแอดเดรสได้เพียงพอสำหรับการจัดเก็บล่าม Python และระบบปฏิบัติการ

Cubix , 9.670457478596419e + 147 (ไม่แข่งขัน)

****"///**

ไม่ใช่การแข่งขันเนื่องจาก Cubix ใหม่กว่าความท้าทายนี้ คุณสามารถทดสอบออนไลน์ได้ที่นี่แต่โปรดทราบว่ามันไม่ได้พิมพ์ตัวเลขจริง คุณจะต้องหยุดโปรแกรมชั่วคราวหลังจากที่*มีการเรียกใช้สองวินาทีล่าสุดเพื่อดูค่าในสแต็ก

มันทำงานอย่างไร

Cubix เป็น esolang 2 มิติที่มีการห่อโค้ดไว้รอบ ๆ cube รหัสนี้เทียบเท่ากับ cube net ดังต่อไปนี้โดยที่.ไม่มีตัวเลือก:

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

จากนั้นโค้ดจะถูกรันโดยตัวชี้คำแนะนำ (IP) เริ่มต้นที่มุมซ้ายบนของใบหน้าซ้ายสุดหันไปทางขวา "เปิดโหมดสตริงโดยที่ทุกตัวอักษรเจอจนกระทั่งตัวอักษรตัวถัดไปส่งไป"ยังสแต็ก IP ล้อมรอบทุกรอบรหัสผลักดันสาม/s (47), สอง*s (42), และสอง.s (46) ไปที่สแต็กก่อนออกจากโหมดสตริงอีกครั้ง

นี่คือสิ่งที่มันน่าสนใจ กระจกแรก/สะท้อน IP ดังนั้นมันจึงหงายขึ้น จากนั้นมันจะหมุนไปรอบ ๆ ลูกบาศก์กดปุ่มตัวอักษรเหล่านี้:

           
    * *
  /     *      
  .     .      
    . .

สามรายการ*คูณสองรายการแรกบนสแต็ก ตอนนี้ซึ่งแตกต่างจากภาษาสแต็กส่วนใหญ่ที่ผู้ประกอบการทางคณิตศาสตร์ปรากฏข้อโต้แย้งของพวกเขา Cubix ออกจากค่าก่อนหน้านี้ในกอง 46*46 = 2116, 46*2116 = 97336, 2116*97336 = 205962976ดังนั้นหมายความคำนวณนี้

เมื่อ IP ถึงจุด/อีกครั้งมันจะเลี้ยวขวา จากนั้นจะกระทบกระจกถัดไปและตามเส้นทางนี้:

    *  
    *  
    /         .
    .         .
    .  
    .  

เครื่องหมายดอกจันสองตัวคูณสองรายการบนสุดอีกครั้ง จากนั้นมิเรอร์จะชี้นำ IP อีกครั้งและมิเรอร์ที่สามจะทำซ้ำกระบวนการอีกครั้ง:

      *
      *
      /     .  
      .     .  
      .
      .

ในที่สุด IP ออกจากส่วนกระจกมุ่งหน้าไปทางทิศตะวันออก เครื่องหมายดอกจัน finaly สองอันทวีคูณสองครั้งเพิ่มขึ้นเป็นผลให้ 9.670457478596419e + 147 บนกองซ้อน สิ่งนี้สามารถพิมพ์ด้วยOแต่ไม่มีวิธีง่ายๆในการทำเช่นนั้นเนื่องจากใช้งานได้จริงทุกจุดบนคิวบ์แล้ว

สกาลา, 2 ⁶³ -1

สกาล่าไม่ดี ใช้เวลาอย่างน้อย 8 ตัวอักษรเพื่อรับBigIntค่าซึ่งไม่ได้มีที่ว่างเพียงพอที่จะทำให้มันใหญ่

แต่ด้วยรหัส (นับ) เพียง 7 ตัวอักษรเราสามารถพิมพ์ค่าบวกที่เป็นไปได้ที่ใหญ่ที่สุดLong:

print(-1L>>>1)

Brainf ** k 256 - 2147483647

>+[<+>+]<.

_{หากคุณเพิกเฉยต่อความจริงที่ว่าคอมไพเลอร์ & ล่ามส่งออกข้อมูลเนื่องจากมันเป็นแบบ ASCII เทียบเท่ากัน (เป็นแบบผ่อนปรนมันคืออะไร;))}สิ่งนี้จะส่งคืนค่าสูงสุดของประเภทข้อมูลของล่าม / ผู้แปล

ในบางระบบนี่เป็นเพียง 256 แม้ว่าในบางระบบ (เช่นของฉัน) นี่เป็นค่าสูงสุดของจำนวนเต็ม 32 บิตเช่น 2 147 483 647

แก้ไข:

-.

จะพิมพ์สิ่งเดียวกันในตัวละครน้อยลง

Perl ไม่ใช่การแข่งขัน

ฉันใช้สิ่งนี้เพื่อเน้นมุมเล็ก ๆ ของ perl

Perl ไม่สามารถแข่งขันกับอันนี้ได้เพราะมันไม่มีบิกนิวในตัว (แน่นอนคุณสามารถโหลดไลบรารี่ bignum) ได้

แต่สิ่งที่ทุกคนรู้ไม่เป็นความจริงอย่างสมบูรณ์ ฟังก์ชั่นแกนหนึ่งที่จริงสามารถจัดการกับตัวเลขขนาดใหญ่ได้

packรูปแบบwจริงสามารถแปลงจำนวนธรรมชาติขนาดใด ๆ ระหว่างฐานและฐาน10 128จำนวนเต็มฐาน 128 จะถูกแทนด้วยจำนวนไบต์สตริง bitstring xxxxxxxyyyyyyyzzzzzzzกลายเป็นไบต์: 1xxxxxxx 1yyyyyyy 0zzzzzzz(ทุก ๆ ไบต์เริ่มต้นด้วย 1 ยกเว้นอันสุดท้าย) และคุณสามารถแปลงสตริงดังกล่าวเป็นเบส 10 ด้วยการแกะ ดังนั้นคุณสามารถเขียนรหัสเช่น:

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

ซึ่งจะช่วยให้:

17440148077784539048602210552864286760481312243331966651657423831944908597692986131110771184688683631223604950868378426010091037391551287028966465246275171764867964902846884403624214574779667949236313638077978794791039372380746518407204456880869394123452212674801443116750853569815557532270825838757922217314748231826241930826238846175896997055564919425918463307658663171965135057749089077388054942032051553760309927468850847772989423963904144861205988704398838295854027686335454023567793114837657233481456867922127891951274737700618284015425

คุณสามารถแทนที่4**4ด้วยค่าที่มากขึ้นจนกว่าคุณจะรู้สึกว่ามันใช้เวลานานเกินไปหรือใช้หน่วยความจำมากเกินไป

น่าเสียดายที่มันยาวเกินไปสำหรับขีด จำกัด ของความท้าทายนี้และคุณสามารถยืนยันได้ว่าผลลัพธ์ฐาน 10 ถูกแปลงเป็นสตริงก่อนที่มันจะกลายเป็นผลลัพธ์ดังนั้นการแสดงออกไม่ได้สร้างจำนวนจริง แต่ภายใน perl ทำเลขคณิตที่จำเป็นจริงๆในการแปลงอินพุตเป็นฐาน 10 ซึ่งฉันถือว่าค่อนข้างเรียบร้อย

TI-36 (ไม่ใช่ 84, 36), 10 ไบต์, โดยประมาณ 9.999985426E99

เครื่องคิดเลขรุ่นเก่าสามารถตั้งโปรแกรมได้ในระดับหนึ่งเช่นกัน;)

69!58.4376

ซึ่งใกล้เคียงกับช่วงสูงสุดที่เครื่องคิดเลข TI สามารถแสดงได้:-1E100<x<1E100

Perl 6 , 456,574 หลัก

[*] 1..ↈ

ไม่มี TIO เนื่องจากต้องใช้เวลา 2 นาที