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

สมมติว่าคุณพิมพ์10000000และรหัสของคุณมีความ100ยาวไบต์ 10000000 / 100^3 = 10คะแนนสุดท้ายของคุณจะ

มีกฎอื่น ๆ ที่ต้องปฏิบัติตามเพื่อให้ความท้าทายนี้ยากขึ้นเล็กน้อย

• คุณไม่สามารถใช้ตัวเลขในรหัสของคุณ (0123456789);
• คุณสามารถใช้คณิตศาสตร์ / กายภาพ / ฯลฯ ค่าคงที่แต่ถ้าพวกมันน้อยกว่า 10 (เช่นคุณสามารถใช้Pi ~ = 3.14 แต่คุณไม่สามารถใช้ค่าคงที่ Avogadro = 6e23)
• อนุญาตให้เรียกซ้ำได้แต่จำนวนที่สร้างต้องมีจำนวน จำกัด (ดังนั้นอนันต์จึงไม่ได้รับการยอมรับว่าเป็นวิธีแก้ปัญหาโปรแกรมของคุณจำเป็นต้องยุติอย่างถูกต้องโดยสมมติเวลาและหน่วยความจำไม่ จำกัด และสร้างผลลัพธ์ที่ร้องขอ);
• คุณไม่สามารถใช้การดำเนินการ*(ทวีคูณ), /(หาร), ^(กำลัง) หรือวิธีอื่นใดในการบ่งชี้พวกเขา (เช่น2 div 2ไม่ได้รับอนุญาต);
• โปรแกรมของคุณสามารถส่งออกจำนวนมากกว่าหนึ่งถ้าคุณต้องการที่จะทำ เฉพาะคะแนนสูงสุดเท่านั้นที่จะนับเพื่อให้คะแนน
• อย่างไรก็ตามคุณสามารถเชื่อมสตริงได้: หมายความว่าลำดับใด ๆ ของตัวเลขที่อยู่ติดกันจะถูกพิจารณาเป็นตัวเลขเดียว
• รหัสของคุณจะถูกเรียกใช้ตามสภาพ ซึ่งหมายความว่าผู้ใช้ปลายทางไม่สามารถแก้ไขบรรทัดของรหัสใด ๆ และไม่สามารถป้อนหมายเลขหรือสิ่งอื่นใด
• ความยาวรหัสสูงสุดคือ 100 ไบต์

ลีดเดอร์บอร์ด

1. Steven H. , Pyth ≈ f _{φ (1,0,0) +7} (256 ²⁶ ) / 1000000 ^[1]
2. ซิมเพิลอาร์ทสวย , ทับทิม ≈ f _{φ 121 (ω)} (126) ^[1]
3. Peter Taylor , GolfScript Golf 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. เพียงแค่ศิลปะที่สวยงามทับทิม ≈ฉ_{โอห์ม^ω2 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. Magenta , Python, ≈ ack (126,126) / 100 ³ ≈ 10 ↑ ¹²⁴ 129
11. เคนดอลเฟรย์ , 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. ซ้ำ , Python, ≈ 2 ↑↑ 11/95 ³ ≈ 10 ↑↑ 8.63297 ^{[1] [3]}
15. นาโนเมตร , Haskell, ≈ 2 ↑↑ 7/100 ³ ≈ 10 ↑↑ 4.63297 ^[1]
16. เดวิด Yaw , C, ≈ 10 ^{10 4 × 10 22} /83 ³ ≈ 10 ↑↑ 4.11821 ^[2]
17. พรีโม่ , Perl, ≈ 10 ^{(12750684161!) 5 × 2 27} /100 ³ ≈ 10 ↑↑ 4.11369
18. ศิลปะ , 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 Stone , C, C 10 ^{10 97.61735} / 98 ³ ≈ 10 ↑↑ 3.29875
22. ecksemmess , C, ≈ 10 ^{2 320} /100 ³ ≈ 10 ↑↑ 3.29749
23. อดัม Speight , vb.net, ≈ 10 ^{5000 × (2 64 ) 4} /100 ³ ≈ 10 ↑↑ 3.28039
24. โจชัว , ทุบตี ≈ 10 ^{10 15} /86 ³ ≈ 10 ↑↑ 3.07282

_{เชิงอรรถ}

1. ^{หากอิเล็กตรอนทุกตัวในเอกภพมีค่าบิตและทุก ๆ การซ้อนทับของมันนั้นสามารถนำไปใช้เป็นประโยชน์ในการเก็บข้อมูล (ซึ่งตราบใดที่คุณไม่จำเป็นต้องรู้ว่าสิ่งที่ถูกเก็บไว้นั้นเป็นไปได้ในทางทฤษฎี) โปรแกรมนี้ต้องการหน่วยความจำมากกว่า อาจมีอยู่และดังนั้นจึงไม่สามารถเรียกใช้ - ตอนนี้หรือ ณ จุดที่มองเห็นได้ในอนาคต หากผู้แต่งตั้งใจจะพิมพ์ค่าที่มากกว่า≈3↑↑ 3.28 ทั้งหมดในครั้งเดียวเงื่อนไขนี้จะใช้}
2. ^{โปรแกรมนี้ต้องการหน่วยความจำมากกว่าที่มีอยู่ในปัจจุบัน แต่ไม่มากจนไม่สามารถเก็บไว้ในทางทฤษฎีในจำนวนที่น้อยของ qubits ดังนั้นวันหนึ่งคอมพิวเตอร์อาจมีอยู่ซึ่งสามารถเรียกใช้โปรแกรมนี้ได้}
3. ^{ล่ามทั้งหมดที่มีอยู่ในปัจจุบันมีปัญหาข้อผิดพลาดรันไทม์หรือโปรแกรมไม่สามารถดำเนินการตามที่ผู้เขียนต้องการ}
4. ^{การรันโปรแกรมนี้จะทำให้ระบบของคุณเสียหายอย่างไม่สามารถแก้ไขได้}

แก้ไข @primo : ฉันได้อัปเดตส่วนหนึ่งของกระดานคะแนนโดยใช้หวังว่าจะเปรียบเทียบสัญกรณ์ได้ง่ายขึ้นโดยใช้ทศนิยมเพื่อแสดงระยะทางลอการิทึมเป็นพลังงานที่สูงขึ้นต่อไป ยกตัวอย่างเช่น 10 ↑↑ 2.5 = 10 ¹⁰ √10 ฉันได้เปลี่ยนคะแนนบางส่วนถ้าฉันเชื่อว่าการวิเคราะห์ของผู้ใช้เป็นความผิดพลาดคุณสามารถโต้แย้งสิ่งเหล่านี้ได้

คำอธิบายของเอกสารนี้:

หากแล้ว0 ≤ b < 1a↑↑b = ab

หากแล้วb ≥ 1a↑↑b = aa↑↑(b-1)

หากแล้วb < 0a↑↑b = loga(a↑↑(b+1))

GolfScript; ทำคะแนนอย่างน้อย f _{ε_0 + ω + 1} (17) / 1,000

ต่อไปนี้ความละเอียดของข้อเสนอแนะการใช้ชีวิตของหนอนคำตอบสำหรับคำถามนี้ผมนำเสนอสองโปรแกรมซึ่งอย่างมากมายปรับปรุงเกี่ยวกับแหล่งที่มาของการแก้ปัญหาของเขาโฮเวิร์ด

พวกเขาแบ่งปันคำนำหน้าทั่วไป modulo ชื่อฟังก์ชั่น:

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

คำนวณg(g(1)) = g(5)ที่g(x) = worm_lifetime(x, [x])เพิ่มขึ้นอย่างคร่าวๆเมื่อ f _{ε 0} (ซึ่งรีโน้ตซึ่งเป็น "ฟังก์ชันในลำดับชั้นที่เพิ่มขึ้นอย่างรวดเร็วซึ่งเติบโตในอัตราเดียวกับฟังก์ชัน Goodstein")

การวิเคราะห์ที่ง่ายกว่า (!) เล็กน้อยก็คือ

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

.{foo}*แผนที่จะxfoo^x x

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

จึงให้g^(g(5)) ( g(5) ); การทำซ้ำอีก 8 ระดับจะคล้ายกับการโยงลูกศร ที่จะแสดงในแง่ง่ายๆถ้าh_0 = gและแล้วเราจะคำนวณh_{i+1} (x) = h_i^x (x)h_10 (g(5))

ฉันคิดว่าโปรแกรมที่สองนี้เกือบจะทำคะแนนได้ดีกว่า เวลานี้เลเบลที่กำหนดให้กับฟังก์ชันgเป็นบรรทัดใหม่ (sic)

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

คราวนี้ฉันใช้^ฟังก์ชั่นต่าง ๆให้ดีขึ้น

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

ใช้เวลาxในกองซ้อนและใบxตามด้วยสตริงที่มีxสำเนา.{ตามด้วยgตามด้วยxสำเนาของ}*; จากนั้นประเมินสตริง ตั้งแต่ฉันได้สถานที่ที่ดีที่จะเผาไหม้ตัวละครเสริม, เราเริ่มต้นด้วยj_0 = g; ถ้าเป็นเช่นj_{i+1} (x) = j_i^x (x)นั้นการประเมินผลครั้งแรกของการ^คำนวณj_{g(5)} (g(5))(ซึ่งฉันค่อนข้างแน่ใจแล้วว่าชนะโปรแกรมก่อนหน้า) จากนั้นฉันรัน^อีก 16 ครั้ง; ดังนั้นถ้าk_0 = g(5)และแล้วก็จะคำนวณk_{i+1} = j_{k_i} (k_i) k_17ฉันรู้สึกขอบคุณ (อีกครั้ง) ที่จะ res สำหรับการประมาณว่าk_i>> f _{ε_0 + ω + 1} (i)

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

หมายเหตุ: อย่าทำสิ่งนี้!

บันทึกสิ่งต่อไปนี้เป็นไฟล์แบตช์และเรียกใช้ในฐานะผู้ดูแลระบบ

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

เอาต์พุตเมื่อรันบนไดร์ฟ 4TB โดยพิมพ์หมายเลขแรกเป็นตัวหนา

ใส่ดิสก์ใหม่สำหรับไดรฟ์ D:
แล้วกด ENTER เมื่อพร้อม ... ประเภทของระบบไฟล์คือ NTFS
ระบบไฟล์ใหม่คือ FAT
การจัดรูปแบบด่วน3907172M
ระดับเสียงใหญ่เกินไปสำหรับ FAT16 / 12

GolfScript คะแนน: วิธีมากเกินไป

ตกลงเราสามารถพิมพ์จำนวนเท่าใดใน GolfScript สักสองสามตัว

มาเริ่มด้วยโค้ดต่อไปนี้ ( ขอบคุณเบ็น! ) ซึ่งจะพิมพ์126:

'~'(

ต่อไปเราทำซ้ำได้ 126 ครั้งโดยให้ตัวเลขเท่ากับ 1.26126 × 10 ³⁷⁷ :

'~'(.`*

(นั่นคือการทำซ้ำสตริงไม่ใช่การคูณดังนั้นจึงควรตกลงภายใต้กฎ)

ทีนี้มาทำซ้ำที่หมายเลข 378 หลักมากกว่า 10 ³⁷⁷ครั้ง:

'~'(.`*.~*

คุณจะไม่เคยเห็นจริงจบโปรแกรมนี้เพราะมันพยายามที่จะคำนวณจำนวนที่มีประมาณ 10 ³⁸⁰ ≈ 2 ¹¹⁴⁰ตัวเลข ไม่มีคอมพิวเตอร์เครื่องใดที่สามารถสร้างจำนวนมหาศาลและไม่สามารถสร้างคอมพิวเตอร์ที่ใช้ฟิสิกส์ที่รู้จัก จำนวนของอะตอมในจักรวาลคาดว่าจะอยู่ที่ประมาณ 10 ⁸⁰ดังนั้นแม้ว่าเราก็สามารถใช้เรื่องทั้งหมดในจักรวาลในการจัดเก็บจำนวนมากนี้เรายังคงต้องการอย่างใดต้องอัดประมาณ 10 ³⁸⁰ /10 ⁸⁰ = 10 ³⁰⁰หลักในแต่ละอะตอม!

แต่สมมติว่าเรามีล่าม GolfScript ของพระเจ้าสามารถทำการคำนวณได้และเรายังไม่พอใจ ตกลงมาทำอีกครั้ง!

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

ผลลัพธ์ของโปรแกรมนี้ถ้ามันจะเสร็จสมบูรณ์จะมีประมาณ 10 ^{10 383}ตัวเลขและอื่น ๆ จะเท่ากับประมาณ 10 ^{10 10} 383

แต่เดี๋ยวก่อน! โปรแกรมนั้นได้รับการซ้ำซาก ... ทำไมเราไม่เปลี่ยนเป็นวง

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

ที่นี่ร่างกายของวงวิ่งประมาณ 10 ³⁷⁷ครั้งให้ผลลัพธ์ทางทฤษฎีซึ่งประกอบด้วย 10 10 ^{about 10 377}หลักหรือมากกว่านั้นที่หอคอยแห่งพลังซ้ำ 10 มีความยาวประมาณ³⁷⁷ขั้นตอน (ที่จริงแล้วนั่นคือการดูถูกดูแคลนขั้นต้นเนื่องจากฉันเพิกเฉยต่อความจริงที่ว่าจำนวนที่เกิดขึ้นซ้ำ ๆ นั้นก็ยิ่งนานขึ้นทุกครั้ง แต่การพูดค่อนข้างเป็นเรื่องเล็กน้อย)

แต่เรายังไม่ได้ทำ มาเพิ่มอีกหนึ่งวง!

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

หากต้องการเขียนตัวเลขที่ประมาณไว้อย่างถูกต้องต้องใช้สัญกรณ์ทางคณิตศาสตร์ที่ลึกลับ ยกตัวอย่างเช่นในKnuth up-arrow notationจำนวนเอาต์พุต (ตามหลักทฤษฏี) จากโปรแกรมข้างต้นควรจะประมาณ 10 ↑ ³ 10 ³⁷⁷ให้หรือใช้กำลังน้อย (หรือ 10 ³⁷⁷ ) พลังของสิบสมมติว่าฉันทำคณิตศาสตร์ถูกต้อง

ตัวเลขเช่นนี้ทำให้เหนือกว่า "ขนาดใหญ่อย่างไม่น่าเชื่อ" และเข้าสู่อาณาจักรแห่ง "นึกไม่ถึง" ในนั้นไม่เพียง แต่เป็นไปไม่ได้ที่จะนับหรือเขียนตัวเลขดังกล่าว (เราข้ามผ่านจุดนั้นไปแล้วในตัวอย่างที่สามด้านบน) แต่พวกเขาไม่มีการใช้หรือการมีอยู่นอกคณิตศาสตร์นามธรรม เราสามารถพิสูจน์ได้จากสัจพจน์ของคณิตศาสตร์ที่มีจำนวนดังกล่าวเหมือนกับที่เราสามารถพิสูจน์ได้จากข้อมูลจำเพาะ GolfScript ที่โปรแกรมข้างต้นจะคำนวณพวกเขาหากข้อ จำกัด ของความเป็นจริงและพื้นที่เก็บข้อมูลที่ว่างไม่ได้แทรกแซง) แต่ไม่มีอะไรใน จักรวาลทางกายภาพที่เราสามารถใช้เพื่อนับหรือวัดในแง่ใด ๆ

ถึงกระนั้นบางครั้งนักคณิตศาสตร์ก็ใช้ประโยชน์จากจำนวนที่มากกว่านี้ (ในทางทฤษฎี) การคำนวณตัวเลขที่มีขนาดใหญ่ใช้เวลาทำงานมากกว่านิดหน่อย - แทนที่จะเพียงแค่ทำซ้ำลูปทีละหนึ่งเราต้องใช้การเรียกซ้ำเพื่อกล้องโทรทรรศน์ความลึกของลูปซ้อนกัน แต่ถึงกระนั้นในหลักการที่ควรจะเป็นไปได้ที่จะเขียนโปรแกรม GolfScript สั้น ๆ (ดีภายใต้ 100 ไบต์ผมจะคาดหวัง) ถึง (ทฤษฎี) คำนวณจำนวนใด ๆ ที่แสดงออกในการพูด, คอนเวย์ถูกล่ามโซ่ลูกศรสัญกรณ์ ; รายละเอียดจะถูกทิ้งไว้เป็นแบบฝึกหัด ;-)

จาวาสคริปต์ 44 ตัว

นี่อาจดูเหมือนโกงเล็กน้อย:

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

คะแนน = 31415926535897932718281828459045/44 ^ 3 ≈ 3.688007904758867e + 26 ≈ 10 ↑↑ 2.1536134004

C, คะแนน = 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);}

ฉันขอขอบคุณความช่วยเหลือในการให้คะแนน ข้อมูลเชิงลึกหรือการแก้ไขใด ๆ ที่ได้รับการชื่นชม นี่คือวิธีการของฉัน:

n = เรียงต่อกันของจำนวนทุก 1-2 ⁶⁴ -1 ซ้ำ (2 ⁶⁴ -1) ⁴ครั้ง อย่างแรก, นี่คือวิธีที่ฉันประมาณ (ต่ำ) จำนวนหลักสะสมจาก 1 ถึง 2 ⁶⁴ -1 ("" การเรียงลำดับ "): หมายเลขสุดท้ายในลำดับการเรียงคือ 2 ⁶⁴ -1 = 18446744073709551615มี 20 หลัก ดังนั้นมากกว่า 90% ของตัวเลขในการเรียงลำดับ (ที่ขึ้นต้นด้วย1.. 9) มี 19 หลัก สมมติว่า 10% ที่เหลืออยู่โดยเฉลี่ย 10 หลัก มันจะมีอะไรมากกว่านั้น แต่นี่เป็นค่าประมาณต่ำสำหรับคณิตศาสตร์ที่ง่ายและไม่โกง การเรียงลำดับนั้นซ้ำแล้วซ้ำอีก (2 ⁶⁴ -1) ⁴ครั้งดังนั้นความยาวจำนวนnจะเป็นอย่างน้อย (0.9 × (2 ⁶⁴ -1) × 19 + 0.1 × (2 ⁶⁴ -1) × 10) × (2 ⁶⁴ -1) ⁴ = 3.86613 × 10 ⁹⁷หลัก ในความคิดเห็นด้านล่าง @primo ยืนยันความยาวของnจะเป็น 4.1433x10 97 ดังนั้นnตัวเองจะเป็น 10 สู่อำนาจนั้นหรือ 10 ¹⁰ 97.61735

l = 98 ตัวอักษรของรหัส

คะแนน = n / l ³ = 10 ^{10 97.61735} / 98 ³

ความต้องการ: ต้องทำงานบนคอมพิวเตอร์ 64 sizeof(long) == 8บิตที่ Mac และ Linux จะทำเช่นนั้น

Python 3 - 99 chars - (เป็นไปได้มาก) มีขนาดใหญ่กว่าตัวเลขของ Graham อย่างมีนัยสำคัญ

ฉันคิดขึ้นมาพร้อมกับฟังก์ชั่นที่เพิ่มขึ้นอย่างรวดเร็วโดยอิงจากส่วนขยายของฟังก์ชัน 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 เป็นแรงบันดาลใจให้ฉัน แต่คุณไม่จำเป็นต้องดูที่นั่นเพื่อทำความเข้าใจหมายเลขของฉัน

นี่คือฟังก์ชั่น ackermann ที่ได้รับการแก้ไขซึ่งฉันจะใช้ในการวิเคราะห์ของฉัน:

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

ฟังก์ชั่นของฉันAในรหัสด้านบนนั้นไม่เหมือนกันทางเทคนิค แต่จริงๆแล้วมันแข็งแกร่งกว่าด้วยคำสั่งต่อไปนี้เพื่อแทนที่บรรทัดที่สามของคำนิยามข้างต้น:

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

(a ต้องมีอย่างน้อย 1 จึงจะต้องแข็งแกร่งขึ้น)

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

ฟังก์ชั่นของฉันรับประกันว่าจะหยุด recursing ในที่สุดเพราะมันมักจะ: เอาการโต้แย้งลดลงอาร์กิวเมนต์แรกหรือเก็บอาร์กิวเมนต์แรกเดียวกันและลดลงอาร์กิวเมนต์ที่สอง

การวิเคราะห์ขนาด

หมายเลข AFAIK ของเกรแฮมสามารถใช้แทนการG(64)ใช้:

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

สัญลักษณ์↑^(n)b - ลูกศรของ knuth อยู่ที่ไหน

เช่นกัน:

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)

A(0,1,2,3,4,...,123,124,125)จำนวนที่แสดงในโปรแกรมข้างต้นเป็น

เนื่องจากg^64(4)เป็นหมายเลขของ Graham และสมมติว่าคณิตศาสตร์ของฉันถูกต้องแล้วก็น้อยกว่าA(1,64,100)ตัวเลขของฉันจึงมากกว่าตัวเลขของ Graham อย่างมีนัยสำคัญ

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

Perl - คะแนน≈ 10 ↑↑ 4.1

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

อีกครั้งที่ใช้เครื่องมือ regex ของ perl เพื่อบดผ่านชุดค่าผสมที่ไม่สามารถจินตนาการได้ในครั้งนี้โดยใช้เชื้อสายแบบเรียกซ้ำ

ในการแสดงออกส่วนใหญ่ภายในเรามีภาพเปลือย.เพื่อป้องกันการวนซ้ำแบบไม่ จำกัด และ จำกัด ระดับการเรียกซ้ำตามความยาวของสตริง

สิ่งที่เราจะได้คือ:

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

... ทำซ้ำ671088640ครั้งรวมทั้งสิ้น12750684161 การทำรัง - ซึ่งค่อนข้างละเอียดทำให้การพยายามครั้งที่23ของฉันทำรัง 23ครั้งน่าละอาย อย่างน่าประหลาดใจ perl ไม่สำลักในเรื่องนี้ (อีกครั้งการใช้หน่วยความจำคงที่ประมาณ 1.3GB) แม้ว่ามันจะใช้เวลาสักครู่ก่อนที่คำสั่งพิมพ์ครั้งแรกจะออกแม้

จากการวิเคราะห์ก่อนหน้านี้ของฉันด้านล่างสามารถสรุปได้ว่าจำนวนของตัวเลขที่ส่งออกจะอยู่ในลำดับของ(! 12750684161) ^671088640โดยที่! kเป็นแฟคทอเรียลด้านซ้ายของk (ดูA003422 ) เราสามารถประมาณสิ่งนี้เป็น(k-1)! ซึ่งมีขนาดเล็กกว่าอย่างเข้มงวด แต่มีขนาดเท่ากัน

และถ้าเราถาม wolframalpha :

... ซึ่งแทบจะไม่เปลี่ยนคะแนนของฉันเลย ผมคิดว่าสำหรับแน่ใจว่าต้องการจะอย่างน้อย10 ↑↑ 5 ฉันเดาว่าความแตกต่างระหว่าง10 ↑↑ 4และ10 ↑↑ 4.1นั้นใหญ่กว่าที่คุณคิด

Perl - คะแนน≈ 10 ↑↑ 4

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

การใช้เครื่องมือ regl ของ perl เพื่อทำ combinatorics ให้เรา codeblock แบบฝัง
(??{print})จะแทรกผลลัพธ์ลงใน regex โดยตรง เนื่องจาก$_ประกอบด้วย2s ทั้งหมด(และผลลัพธ์ของการprintเป็นเสมอ1) สิ่งนี้ไม่สามารถจับคู่ได้และส่ง Perl ที่หมุนผ่านชุดค่าผสมที่เป็นไปได้ทั้งหมดซึ่งมีค่อนข้างน้อย

ค่าคงที่ใช้

• $^F- 2จัดการไฟล์สูงสุดของระบบโดยทั่วไป
• $]- หมายเลขรุ่น Perl 5.016002คล้ายกับ

$_เป็นสตริงที่มีตัวเลข2ซ้ำ671088640ครั้ง การใช้หน่วยความจำคงที่ที่ประมาณ 1.3GB การส่งออกเริ่มต้นทันที

การวิเคราะห์

ลองนิยามP _k (n)ให้เป็นจำนวนครั้งที่คำสั่ง print ถูกประมวลผลโดยที่kคือจำนวนของ nestings และnคือความยาวของสตริงบวกหนึ่ง (เพราะฉันไม่อยากเขียนn + 1ทุกที่).

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

ฯลฯ โดยทั่วไปสูตรสามารถสรุปได้ดังต่อไปนี้:

ที่ไหน

นั่นคือแฟคทอเรียลด้านซ้ายของkนั่นคือผลรวมของแฟคทอเรียลทั้งหมดน้อยกว่าk (ดูA003422 )

ฉันไม่สามารถระบุรูปแบบปิดสำหรับD _kและE _kแต่สิ่งนี้ไม่สำคัญมากนักหากเราสังเกตสิ่งนั้น

และ

ด้วย23 ที่อยู่อาศัยสิ่งนี้ทำให้เราได้คะแนนโดยประมาณ:

นี่ควรจะเกือบแน่นอน

แต่เพื่อให้สิ่งนี้เป็นสัญกรณ์ที่มองเห็นได้ง่ายขึ้นเล็กน้อยเราสามารถประมาณฐานของเลขชี้กำลังภายใน:

และเลขชี้กำลังนั้นเอง:

แล้วถาม wolframalpha :

ซึ่งคุณอาจจะแค่โทร10 ↑↑ 4และทำได้ด้วย

Javascript, 10 ↑↑↑↑ 210

100 ตัวอักษร:

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)

ขึ้นอยู่กับการสังเกตว่า iterating ที่สุดfคือวิธีที่ดีที่สุดที่จะไปฉันแทนที่ 13 สายที่จะfมี 3 ระดับของลูปซ้อนกันโทรf, zครั้ง (ในขณะที่fช่วยเพิ่มz)

ฉันประเมินคะแนนการวิเคราะห์บนกระดาษ - ฉันจะพิมพ์มันถ้าใครสนใจดู

ปรับปรุงคะแนน: 10 ↑↑ 13

Javascript ในจำนวน 100 ตัวอักษรอีกครั้ง:

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)

นี่ช่วยปรับปรุงคำตอบดั้งเดิมของฉันได้สามวิธี -

1. การกำหนด zขอบเขตทั่วโลกช่วยให้เราไม่ต้องพิมพ์o.zในแต่ละครั้ง

2. เป็นไปได้ที่จะกำหนดตัวรับสัญญาณบนขอบเขตโกลบอล (หน้าต่าง) และประเภท fo.fแทน

3. การทำซ้ำมากกว่าfมีค่ามากกว่าเริ่มต้นด้วยจำนวนที่มากขึ้นดังนั้นแทนที่จะ(Math.E+'').replace('.','')(= 2718281828459045, 27 ตัวอักษร) จะดีกว่าที่จะใช้~~Math.E+'' (= 2, 11 ตัวอักษร) และใช้อักขระกู้เพื่อโทรได้fหลายครั้ง

เนื่องจากดังที่วิเคราะห์เพิ่มเติมด้านล่างการทำซ้ำแต่ละครั้งจะสร้างจากตัวเลขในลำดับความสำคัญMซึ่งเป็นจำนวนที่มากขึ้นตามลำดับขนาด 10 ^เมตรรหัสนี้จะสร้างขึ้นหลังจากการทำซ้ำแต่ละครั้ง

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

คะแนน: ∼10 ^{10 10 10 10 16} ≈ 10 ↑↑ 6.080669764

Javascript ใน 100 ตัวอักษร:

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)

แต่ละอันo.fจะเรียกใช้ลูป while ในจำนวนทั้งหมด 5 ลูป หลังจากนั้นเพียงซ้ำแรกคะแนนที่มีอยู่แล้วกว่า 10 42381398144233621 จากการวนซ้ำครั้งที่สอง Mathematica ไม่สามารถคำนวณได้แม้แต่จำนวนตัวเลขในผลลัพธ์

นี่คือคำแนะนำของรหัส:

ในนั้น

เริ่มต้นด้วย 2718281828459045 Math.Eโดยการเอาจุดทศนิยมจาก

การวนซ้ำ 1

เชื่อมต่อลำดับของตัวเลขที่ลดลง

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

เพื่อสร้างหมายเลข (ขนาดยักษ์) ใหม่

• 271828182845904527182818284590442718281828459043 ... 9876543210

จำนวนนี้มีกี่หลัก? มันเป็นการต่อกันของ

• 1718281828459046 ตัวเลข 16 หลัก
• ตัวเลข 15 หลัก 900000000000000
• 90000000000000 หมายเลข 14 หลัก
• ตัวเลข 9000000000000 13 หลัก
• ...
• ตัวเลข 3 หลัก 900 ตัว
• 90 ตัวเลข 2 หลัก
• 10 ตัวเลข 1 หลัก

ใน Mathematica

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

ในคำอื่น ๆ ก็2.72⋅10 42381398144233625

ทำให้คะแนนของฉันหลังจากนั้นเพียงการย้ำแรก2.72⋅10 42381398144233619

การวนซ้ำ 2

แต่นั่นเป็นเพียงจุดเริ่มต้น ตอนนี้ทำซ้ำขั้นตอนเริ่มต้นด้วยหมายเลขมโหฬาร ! นั่นคือเรียงลำดับของตัวเลขที่ลดลง

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

ดังนั้นคะแนนใหม่ของฉันคือ Mathematica?

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

ซ้ำ 3

ทำซ้ำ

การวนซ้ำ 4

ทำซ้ำ

การวนซ้ำ 5

ทำซ้ำ

คะแนนการวิเคราะห์

ในการคำนวณซ้ำครั้งแรกเราคำนวณจำนวนหลักในการเรียงลำดับของการลดลำดับเริ่มต้นที่ 2718281828459045 โดยการนับจำนวนหลักใน

• 1718281828459046 ตัวเลข 16 หลัก
• ตัวเลข 15 หลัก 900000000000000
• 90000000000000 หมายเลข 14 หลัก
• ตัวเลข 9000000000000 13 หลัก
• ...
• ตัวเลข 3 หลัก 900 ตัว
• 90 ตัวเลข 2 หลัก
• 10 ตัวเลข 1 หลัก

ผลรวมนี้สามารถแสดงโดยสูตร

โดยที่Zหมายถึงหมายเลขเริ่มต้น ( เช่น 2718281828459045) และO _Zหมายถึงลำดับความสำคัญ ( เช่น 15 ตั้งแต่Z ∼ 10 ¹⁵ ) การใช้สิ่งเทียบเท่าสำหรับผลบวกอัน จำกัดข้างต้นสามารถแสดงได้อย่างชัดเจนว่า

ซึ่งถ้าเราใช้ 9 ≈ 10 ให้ลดลงไปอีก

และในที่สุดการขยายคำศัพท์และการเรียงลำดับโดยการลดลำดับความสำคัญเราก็ได้

ทีนี้เนื่องจากเราสนใจเพียงลำดับความสำคัญของผลลัพธ์เรามาแทนที่Zด้วย "ตัวเลขในลำดับความสำคัญของO _Z "คือ 10 ^{O _Z} -

ในที่สุดเทอมที่ 2 และ 3 จะถูกยกเลิกและสองเทอมสุดท้ายสามารถถูกดร็อปได้

จากที่คำแรกชนะ

ปรับปรุงใหม่, fใช้ตัวเลขในลำดับความสำคัญของMและสร้างตัวเลขโดยประมาณตามลำดับความสำคัญของM (10 ^M )

การวนซ้ำครั้งแรกสามารถตรวจสอบได้ง่าย ๆ ด้วยมือ 2718281828459045 เป็นตัวเลขตามลำดับขนาด 15 - ดังนั้นfควรสร้างตัวเลขตามลำดับขนาด 15 (10 ¹⁵ ) ∼ 10 16 แน่นอนจำนวนที่ผลิตได้คือจากก่อนหน้านี้2.72⋅10 ^{42381398144233625} - นั่นคือ 10 ^{42381398144233625} 10 ^{10 16} 16

สังเกตว่า Mไม่ใช่ปัจจัยสำคัญในM (10 ^M ) ลำดับความสำคัญของผลลัพธ์ของการวนซ้ำแต่ละครั้งจากนั้นตามรูปแบบที่เรียบง่ายของการทำซ้ำ:

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

แหล่งน้ำยาง

(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

นี่คือความพยายามแก้ไขของฉัน:

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

โปรแกรม 100 char / byte * ซึ่งทำงานบนฮาร์ดแวร์ปัจจุบัน (ใช้หน่วยความจำจำนวนเล็กน้อยและตัวแปร int แบบ 32 บิตปกติ) แม้ว่ามันจะใช้เวลานานกว่าจะเสร็จสมบูรณ์

คุณสามารถเรียกใช้งานได้กับล่าม APL และจะเริ่มพิมพ์ตัวเลข หากอนุญาตให้ดำเนินการเสร็จจะมีหมายเลขที่พิมพ์ด้วย 10 × 123456789 ⁴⁴หลัก

ดังนั้นคะแนนคือ 10 ^{10 × 123456789 44} /100 ³ ≈ 10 ^{10 353} ≈ 10 ↑↑ 3.406161

คำอธิบาย

• ⎕D เป็นสตริงคงที่ที่กำหนดไว้ล่วงหน้าเท่ากับ '0123456789'
• n←⍎⎕Dกำหนดnเป็นตัวเลขที่แสดงโดยสตริงนั้น: 123456789 (ซึ่งคือ <2 ³¹และดังนั้นจึงสามารถใช้เป็นตัวแปรควบคุมการวนซ้ำได้)
• {⍞←⎕D} จะพิมพ์ตัวเลข 10 หลักไปยังเอาต์พุตมาตรฐานโดยไม่ต้องขึ้นบรรทัดใหม่
• {⍞←⎕D}⍣nจะทำมันnครั้ง ( ⍣คือ "ผู้ดำเนินการพลังงาน": ไม่ใช่ *, /, หรือ ^ เพราะไม่ใช่การดำเนินการทางคณิตศาสตร์มันคือการวนรอบ)
• {⍞←n}⍣n⍣nจะทำซ้ำการดำเนินการก่อนหน้านี้nครั้งดังนั้นการพิมพ์ 10 หลักn ²ครั้ง
• {⍞←n}⍣n⍣n⍣nจะทำn ³ครั้ง
• ฉันจะพอดีกับ 44 ⍣nในนั้นจึงพิมพ์n ⁴⁴'0123456789'ครั้งสตริง

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
^{*: APL สามารถเขียนด้วยชุดอักขระแบบไบต์เดียว (ดั้งเดิม) ของตัวเองที่จับคู่สัญลักษณ์ APL กับค่าบน 128 ไบต์ ดังนั้นเพื่อจุดประสงค์ในการให้คะแนนโปรแกรมของ N chars ที่ใช้อักขระ ASCII และสัญลักษณ์ APLเท่านั้นจึงถือได้ว่ามีความยาว N ไบต์}

Haskell, คะแนน: (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

โปรแกรมนี้เป็นรหัสบริสุทธิ์ 100 ไบต์ของ Haskell มันจะพิมพ์จำนวน Ackermann ที่สี่ในที่สุดก็ใช้พลังงานที่มีอยู่ทั้งหมดสำคัญและเวลาของจักรวาลและเกินในกระบวนการ (ดังนั้นเล็กน้อยเกินขีด จำกัด อ่อนของ 5 วินาที)

Python, 2 ↑↑ 11/830584 ≈ 10 ↑↑ 8.632971 (สัญลักษณ์ลูกศร Knuth up)

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

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

ใช่นี่กำลังทำการเปลี่ยนแปลงเล็กน้อยในค่าบูลีน Trueได้รับการข่มขู่1ในบริบทนี้ Python มีจำนวนเต็มความยาวโดยพลการ

GolfScript 3.673e + 374

'~'(.`*

ฉันคิดว่า *ได้รับอนุญาตเพราะมันแสดงให้เห็นถึงการทำซ้ำสตริงไม่ได้คูณ

คำอธิบาย: '~'(จะปล่อยให้ 126 (ค่า ASCII ของ "~") บนสแต็ก จากนั้นคัดลอกหมายเลขแปลงเป็นสตริงและทำซ้ำสตริง 126 ครั้ง สิ่งนี้จะช่วยให้126126126126...1.26 e+377ซึ่งมีประมาณ การแก้ปัญหาคือ 7 ตัวอักษรดังนั้นหารด้วย7^3สำหรับคะแนนประมาณ3.673e+374

Ruby ความน่าจะเป็นที่ไม่มีที่สิ้นสุดและจำนวน 54 ตัวอักษร

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

x ถูกกำหนดค่าเริ่มต้นเป็น 97 จากนั้นเราทำซ้ำขั้นตอนต่อไปนี้: สร้าง x ตัวเลขสุ่มระหว่าง 0 และ 1 หากพวกเขาเหมือนกันทั้งหมดให้ยุติและพิมพ์ x มิฉะนั้นดับเบิล x และทำซ้ำ เนื่องจากตัวเลขสุ่มของ Ruby มีความแม่นยำ 17 หลักโอกาสในการยกเลิกในขั้นตอนใด ๆ คือ 1 ใน (10e17) ^ x ความน่าจะเป็นที่จะยกเลิกภายในขั้นตอน n จึงเท่ากับผลรวมของ x = 1 ถึง n ของ (1 / 10e17) ^ (2 ^ n) ซึ่งรวมเป็น 1 / 10e34 ซึ่งหมายความว่าสำหรับหมายเลขใด ๆ ไม่ว่าจะมีขนาดใหญ่เพียงใดก็ตามมันไม่น่าเป็นไปได้อย่างล้นเหลือที่โปรแกรมนี้จะให้จำนวนที่น้อยกว่า

แน่นอนตอนนี้คำถามเชิงปรัชญาคือว่าโปรแกรมที่มีโอกาสน้อยกว่า 1 ใน 10 ^ 34 ในการยกเลิกโดยขั้นตอนที่ n สำหรับ n ใด ๆ สามารถบอกได้ว่าเคยยุติลง หากเราถือว่าไม่เพียง แต่เวลาและกำลังที่ไม่สิ้นสุด แต่โปรแกรมนั้นได้รับความสามารถในการเพิ่มความเร็วในอัตราที่เกินกว่าอัตราที่ความน่าจะเป็นของการยุติการลดลงเราสามารถเชื่อได้ในความเป็นจริงแล้ว สิ้นสุดตามเวลาโดยพลการใกล้กับ 1

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

นี่เป็นคำที่ดัดแปลงมาจากคำตอบอื่นโดย @Howard และรวมเอาคำแนะนำจาก @Peter Taylor

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

ความเข้าใจของฉันเกี่ยวกับ GolfScript มี จำกัด แต่ฉันเชื่อว่า*และ^ตัวดำเนินการด้านบนไม่ได้ตัวดำเนินการทางคณิตศาสตร์ที่ห้ามโดย OP

(ฉันจะลบสิ่งนี้อย่างมีความสุขหาก @Howard ต้องการส่งเวอร์ชันของเขาเองซึ่งไม่ต้องสงสัยเลยว่าจะดีกว่ารุ่นนี้ต่อไป)

โปรแกรมนี้คำนวณตัวเลขที่ประมาณ f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126)))) ))) - การวนซ้ำเก้าเท่าของ f _{ε 0} - โดยที่ f _{ε 0}เป็นฟังก์ชันในลำดับชั้นที่เติบโตอย่างรวดเร็วซึ่งเติบโตในอัตราเดียวกันกับฟังก์ชัน Goodstein (f _{ε 0}เติบโตอย่างรวดเร็วว่าอัตราการเจริญเติบโตของ n ของฟรีดแมน (k) ฟังก์ชั่นและของ k เท่าคอนเวย์ถูกล่ามโซ่ลูกศรแทบไม่มีนัยสำคัญแม้ในการเปรียบเทียบกับเพียงหนึ่งเดียวที่ไม่ซ้ำฉ_{ε 0} .)

dc, 100 ตัวอักษร

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

มีเวลาเพียงพอและหน่วยความจำนี้จะคำนวณจำนวนประมาณ 15 ↑¹⁶⁶⁶⁶⁶⁵ 15. ฉันได้ดำเนินการเดิมhyperoperationฟังก์ชั่น แต่มันจำเป็นต้องใช้ตัวอักษรมากเกินไปสำหรับความท้าทายนี้ดังนั้นฉันออกn = 2, b = 0และn >= 3, b = 0เงื่อนไขการเปลี่ยนn = 1, b = 0n >= 1, b = 0สภาพเข้า

ตัวดำเนินการทางคณิตศาสตร์เพียงอย่างเดียวที่ใช้ที่นี่คือการบวกและการลบ

แก้ไข: ตามที่สัญญาไว้ในความคิดเห็นนี่คือรายละเอียดของสิ่งที่รหัสนี้ทำ:

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

ดังที่ระบุไว้นี่จะเบี่ยงเบนจากฟังก์ชั่น hyperoperation ซึ่งเคสพื้นฐานสำหรับการคูณและสูงกว่าจะถูกแทนที่ด้วยเคสพื้นฐานเพื่อเพิ่ม รหัสนี้ทำงานราวกับว่าa*0 = a^0 = a↑0 = a↑↑0 ... = aแทนที่จะถูกต้องทางคณิตศาสตร์a*0 = 0และa^0 = a↑0 = a↑↑0 ... = 1และเป็นผลให้มันคำนวณค่าที่สูงกว่าที่ควรจะเป็นเล็กน้อย แต่นั่นไม่ใช่เรื่องใหญ่เพราะเรากำลังเล็งหาจำนวนที่มากขึ้น :)

แก้ไข: n=0ฉันเพิ่งสังเกตเห็นว่าหลักเล็ดรอดเข้ารหัสโดยอุบัติเหตุในแมโครที่มีประสิทธิภาพเพิ่มขึ้นสำหรับ ฉันได้ลบออกโดยแทนที่ด้วย 'F' (15) ซึ่งมีผลข้างเคียงของการปรับการดำเนินการเพิ่มขึ้นทีละ 15 ฉันไม่แน่ใจว่าสิ่งนี้มีผลต่อผลลัพธ์สุดท้าย แต่อาจใหญ่กว่านี้มาก

ไม่ จำกัด จำนวนรันไทม์อีกต่อไป? โอเคถ้าอย่างนั้น.

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

โซลูชันทั้งสองใช้คอมไพล์ 64 บิตดังนั้น longเป็นจำนวนเต็ม 64 บิต

C: มากกว่า 10 ^{(2 64 -1) 2 64}ซึ่งมากกว่า 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 ตัวอักษร

t = 2^64-1 = 18446744073709551615ที่จะทำให้สูตรเหล่านี้ง่ายกว่าที่ผมจะใช้

mainจะเรียกfกับพารามิเตอร์ของtซึ่งจะห่วงtครั้งแต่ละครั้งพิมพ์ค่าtและเรียกร้องให้มีพารามิเตอร์ของft-1

จำนวนพิมพ์ทั้งหมด: 20 * tตัวเลขรวมพิมพ์:

การเรียกแต่ละครั้งfด้วยพารามิเตอร์t-1จะทำซ้ำtครั้งพิมพ์ค่าtและการเรียก f ด้วยพารามิเตอร์t-2และเรียกฉพารามิเตอร์ของ

จำนวนพิมพ์ทั้งหมด: 20 * (t + t*t)

ฉันลองโปรแกรมนี้โดยใช้จำนวนเต็ม 3 บิตเทียบเท่ากัน (ฉันตั้งค่าi = 8และมีสายหลักf(7)) มันตีงบพิมพ์ 6725600 ครั้ง ที่ได้ผลออกมา7^8 + 7^7 + 7^6 + 7^5 + 7^4 + 7^3 + 7^2 + 7ดังนั้นฉันเชื่อว่านี่เป็นครั้งสุดท้ายสำหรับโปรแกรมเต็มรูปแบบ:

จำนวนพิมพ์ทั้งหมด: 20 * (t + t*t + t^3 + ... + t^(t-1) + t^t + t^(2^64))

ผมไม่แน่ใจว่าวิธีการคำนวณ (2 ⁶⁴ -1) ² 64 ผลรวมนั้นน้อยกว่า (2 ⁶⁴ ) ^{2 64}และฉันต้องการพลังสองอันเพื่อทำการคำนวณนี้ ดังนั้นผมจะคำนวณ (2 ⁶⁴ ) ^{2 64} -1 มันเล็กกว่าผลที่แท้จริง แต่เนื่องจากมันเป็นขุมกำลังสองตัวฉันจึงสามารถแปลงให้เป็นพลังงาน 10 เพื่อเปรียบเทียบกับผลลัพธ์อื่น

ไม่มีใครรู้วิธีการทำผลรวมนั้นหรือวิธีการแปลง (2 ⁶⁴ -1) ^{2 64}ถึง 10 ⁿ ?

20 * 2 ^ 64 ^ (2 ^ 64-1)
20 * 2 ^ 64 ^ 18446744073709551615
20 * 2 ^ (64 * 18446744073709551615)
20 * 2 ^ 1180591620717411303360
10 * 2 ^ 1180591620717411303361
หารเลขชี้กำลังด้วยล็อกฐาน 2 จาก 10 เพื่อสลับฐานของเลขชี้กำลังเป็นกำลัง 10
1180591620717411303361 / 3.32192809488736234787031942948939017586483139303 11903119 = 1180591680 = 
355393490465494856446
10 * 10 ^ 355393490465494856446
10 ^ 355393490465494856447

แต่จำไว้ว่านั่นคือจำนวนตัวเลขที่พิมพ์ออกมา ค่าของจำนวนเต็มคือ 10 ยกกำลังนั้นดังนั้น 10 ^ 10 ^ 355393490465494856447

โปรแกรมนี้จะมีความลึกซ้อนกันเป็น 2 ^ 64 นั่นคือหน่วยความจำ 2 ^ 72 ไบต์เพียงเพื่อจัดเก็บตัวนับลูป นั่นคือเคาน์เตอร์วน 4 พันล้านเทราไบต์ ไม่ต้องพูดถึงสิ่งอื่น ๆ ที่จะเกิดขึ้นบนสแต็กสำหรับระดับการเรียกซ้ำ 2 ^ 64

แก้ไข: แก้ไขข้อผิดพลาดของคู่และใช้ค่าที่แม่นยำยิ่งขึ้นสำหรับ log2 (10)

แก้ไข 2: เดี๋ยวก่อนฉันมีวนรอบที่ printf อยู่นอก มาแก้ไขกันเถอะ iเพิ่มการเริ่มต้น

แก้ไข 3: เมื่อไรฉันก็เลยทำให้คณิตศาสตร์ในการแก้ไขครั้งก่อน แก้ไขแล้ว.

อันนี้จะทำงานบนคอมพิวเตอร์ที่ทันสมัยแม้ว่ามันจะไม่เสร็จเร็ว ๆ นี้

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 ตัวอักษร

นี่จะพิมพ์ bitwise-inverse ของศูนย์ 2 ^ 64-1 หนึ่งครั้งสำหรับการวนซ้ำแต่ละครั้ง 2 ^ 64-1 เป็นตัวเลข 20 หลัก

จำนวนหลัก = 20 * (2^64-1)^7= 14536774485912137805470195290264863598250876154813037507443495139492777780675676806718675718675775618774400058518754280054275618778803 จำนวนของตัวเลข = = 14536774485912137805470195290264863598250876154813037507443495139872713789775675672445638775618774280054218754280054218754280054275618778803

การปัดเศษความยาวโปรแกรมเป็น 100 ตัวอักษรคะแนน = หมายเลขที่พิมพ์ / 1,000,000

คะแนน = 10 ^ 14536774485912137805470195290264863598250876154813037507443495139872713787271377078561867418005421874949058520428005421818494495 คะแนนของฉัน = 10 คะแนน

รหัส R - 49ตัวอักษร 41, 4.03624169270483442 * 10 ^ 5928 ≈ 10 ↑↑ 2.576681348

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

จะพิมพ์ออกมา [ทำซ้ำที่นี่เพียงแค่เริ่ม]:

403624169270483442010614603558397222347416148937479386587122217348........

ECMAScript 6 - 10 ^ 3 ↑↑↑↑ 3/884736

(3 ↑↑↑↑ 3 คือ G (1) โดยที่ G (64) คือหมายเลขของ 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)

เอาต์พุต: 10 ^ 3 ↑↑↑↑ 3

คำแนะนำ:

Gเป็นฟังก์ชั่นที่ G (64) คือหมายเลขของ Graham อินพุตเป็นจำนวนเต็ม เอาท์พุทเป็นสตริง unary เขียนด้วย 0ลบออกเพื่อความกะทัดรัด

Kเป็นฟังก์ชั่น Knuth up-arrow a where ⁿ b โดยที่ a โดยปริยาย 3 อินพุตคือ n, สตริงยูนารีและ b, สตริงยูนารี เอาต์พุตเป็นสตริงที่ไม่พร้อมกัน

u คือ "1"

v คือ "0000" หรือ G (0)

e คือ "000"

C

(ขอโทษด้วยกับ 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 ตัวเลข (9 ... )

l = 100 ตัวอักษรของรหัส

คะแนน≈ 1e + 21359870359209100823950217061695521146027045223566527699470416099417041607227197257807255252280590223619570 ≈ 10 คะแนน

[คะแนน = n ^ 5 / l ^ 3 = (10 ^ (2 ^ 320) -1) / (100 ^ 3) = (10 ^ 213598703592091008239502170616660670470452260670460416078222197806405500229686866705402275660570660570675580975680575675575975675575975675525 [คะแนนของคุณ = n ^ 5 / l ^ 3 = (10 ^ (2 ^ 320) -1) / (100 ^ 3) = (10 ^ 21359870359209100823902190686

โปรดทราบว่าฉันสมควรที่จะถูกเฆี่ยนอย่างไร้ความปราณีสำหรับคำตอบนี้ แต่ไม่สามารถต้านทานได้ ฉันไม่แนะนำให้ทำเหมือนฉันใน stackexchange ด้วยเหตุผลที่ชัดเจน :-P

แก้ไข: มันจะยิ่งยากที่จะต้านทานสิ่งล่อใจไปกับสิ่งที่ชอบ

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

... แต่ฉันคิดว่ากฎที่ตั้งใจ แต่ไม่ได้ระบุไว้ก็คือการพิมพ์ตัวเลขทั้งหมดที่ประกอบขึ้นเป็นตัวเลขจะต้องพิมพ์

ใหม่ทับทิม: คะแนน ~ ฉ_{โอห์ม^ω2 +1} (126 ² 2 ¹²⁶ )

โดยที่ f _α (n) เป็นลำดับชั้นที่เติบโตอย่างรวดเร็ว

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

ลองออนไลน์!

*nคูณด้วยสตริงและอาเรย์เป็นแค่พวกมันน่าจะใช้ได้

รหัสไม่ได้รับการตอบกลับ:

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

โดยที่b.-b<=>0ส่งคืนจำนวนเต็มที่1ใกล้0กว่าbกว่า

คำอธิบาย:

มันพิมพ์ที่เริ่มต้นของการเรียกร้องของทุกคนnH

H[[]]คู่ผสมn( nครั้ง) n = n<<nคือ

H[[0,a,b,c,...,z]]การโทรH[[a,b,c,...,z]]( nครั้ง)

H[[k+1,a,b,c,...,z]]โทรH[[k]*n+[a,b,c,...,z]]( nครั้ง) [k]*n = [k,k,...,k]ที่

H[[-1,a,b,c,...,z]]การโทรH[[n]*n+[a,b,c,...,z]]( nครั้ง)

H[[-(k+1),a,b,c,...,z]]การโทรH[[-k]*n+[a,b,c,...,z]]( nครั้ง)

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

โปรแกรมของฉันเริ่มต้นn = 126จากนั้นโทรH[-n-1]126 ² 2 ¹²⁶ครั้ง

ตัวอย่าง:

H[[0]]จะเรียกH[[]]ซึ่งใช้n = n<<n( nครั้ง)

H[[0,0]]จะโทรH[[0]]( nครั้ง)

H[[1]]จะโทรH[[0]*n]( nครั้ง)

H[[-1]]จะโทรH[[n]*n]( nครั้ง)

H[[-1,-1]]จะโทรH[[n]*n+[-1]]( nครั้ง)

H[[-3]]จะโทรH[[-2]*n]( nครั้ง)

ลองออนไลน์!

ดูการแก้ไขสำหรับสิ่งดีๆอื่น ๆ

Haskell - ฟังก์ชั่น Ackermann นำไปใช้กับผลลัพธ์ 20 ครั้ง - 99 ตัวอักษร

นี่คือโซลูชัน haskell ที่ดีที่สุดที่ฉันสามารถหาได้จากฟังก์ชั่น ackermann - คุณอาจสังเกตเห็นความคล้ายคลึงกันบางอย่างกับโซลูชันของ nm, i = round $ log pi ได้รับแรงบันดาลใจจากที่นั่นและส่วนที่เหลือเป็นเรื่องบังเอิญ: 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

มันรันฟังก์ชั่น ackermann ในตัวเอง 20 ครั้งเริ่มต้นที่หนึ่งลำดับที่ถูก

• 1
• 3
• 61,
• A (61,61)
• a (a (61,61), a (61,61)) --- เราจะเรียกมันว่า₂ (61) หรือ₄ (1) ---
• ₃ (61)
• ...
• ₁₈ (61) หรือ₂₀ (1) ฉันคิดว่านี่ประมาณ g ₁₈ (ดูด้านล่าง)

สำหรับการประเมินวิกิพีเดียพูดว่า:

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

จากจุดนี้เราสามารถเห็น a3 (1) = a (61,61) = 2 ↑ ⁵⁹ 64 + 3 ซึ่งมากกว่า g1 อย่างชัดเจน = 3 ↑ ⁴ 3 เว้นแต่ว่า 3 ตอนเริ่มมีความสำคัญมากกว่าที่ฉันคิด หลังจากนั้นแต่ละระดับใดต่อไปนี้ (ทิ้งคงไม่มีนัยสำคัญใน_n ):

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

หากเหล่านี้เทียบเท่าประมาณแล้ว₂₀ (1) ~ g = 18 คำสุดท้ายใน_n , (เป็น_n-1 ) อยู่ไกลเกินกว่า 3 ดังนั้นจึงอาจสูงกว่ากรัม18 ฉันจะดูว่าฉันสามารถคิดได้ไหมว่ามันจะเพิ่มได้แม้แต่การทำซ้ำครั้งเดียวและรายงานกลับ

รหัสเครื่อง x86 - 100 ไบต์ (ประกอบเป็นไฟล์ MSDOS .com)

หมายเหตุ: อาจทำให้กฎงอเล็กน้อย

โปรแกรมนี้จะแสดงผล 2 ^{(65536 * 8 + 32)}เก้าซึ่งจะให้คะแนนที่ (10 ^{2 524320} -1) / 1000000

ในฐานะตัวนับโปรแกรมนี้ใช้สแต็กทั้งหมด (64kiB) บวกกับการลงทะเบียน 16 บิตสองรายการ

รหัสประกอบ:

8A3E61018CD289166101892663018ED331E4BB3A01438A2627
018827A0300130E4FEC4FEC4FEC410E4FEC400E431C95139CC
75FB31D231C931DBCD3F4175F94275F45941750839D4740D59
4174F85131C939D475F9EBDD8B266301A161018ED0C3535858

สภา:

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

ขนาดไฟล์คือ 45 ไบต์

โปรแกรมคือ:

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

และจำนวนที่ผลิตมีขนาดใหญ่กว่า 10 ^ (10 ^ (10 ^ 1.305451600608433))

ไฟล์ที่ฉันเปลี่ยนเส้นทางไปยังปัจจุบันมีขนาดเกิน 16 Gb และยังคงเพิ่มขึ้นเรื่อย ๆ

โปรแกรมจะยุติในเวลาที่เหมาะสมถ้าฉันมีคอมพิวเตอร์ที่ดีกว่า

คะแนนของฉันไม่สามารถคำนวณได้ด้วยจุดลอยตัวที่มีความแม่นยำสองเท่า

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 ในระบบที่เหมาะสม SHLVL เป็นจำนวนเต็มบวกขนาดเล็ก (โดยปกติจะเป็น 1 หรือ 2 ขึ้นอยู่กับว่า / bin / sh ทุบตีหรือไม่)

64 บิต UNIX เท่านั้น:

คะแนน: ~ 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];);}

เราสร้างอาร์เรย์ของจำนวนเต็ม 258048 ที่ไม่ได้ลงนาม มันยาวไม่ได้ลงชื่อเนื่องจากทำให้โปรแกรมยาวเกินไป พวกเขาไม่ได้ลงชื่อเพราะฉันไม่ต้องการใช้พฤติกรรมที่ไม่ได้กำหนดรหัสนี้เหมาะสม C (นอกเหนือจากการขาดการส่งคืนจาก main ()) และจะรวบรวมและเรียกใช้บนเครื่องปกติใด ๆ มันจะทำงานต่อไปเป็นเวลานาน . ขนาดนี้เป็นขนาดที่ใหญ่ที่สุดที่เราสามารถแสดงได้อย่างถูกกฎหมายโดยไม่ต้องใช้ตัวอักษรที่ไม่ใช่ ASCII

เราวนรอบอาร์เรย์เริ่มต้นจากองค์ประกอบสุดท้าย เราพิมพ์ตัวเลขของ2^32-1เพิ่มองค์ประกอบและปล่อยลูปถ้าองค์ประกอบไม่ได้ห่อเป็น 0 ด้วยวิธีนี้เราจะวนรอบ(2^32 - 1)^254048 = 2^8257536เวลาพิมพ์ 10 หลักในแต่ละครั้ง

นี่คือตัวอย่างโค้ดที่แสดงหลักการในช่วงข้อมูลที่ จำกัด มากขึ้น:

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

ผลลัพธ์คือประมาณ 10 ^ 10 ^ 2485766 หารด้วยล้านซึ่งยังคงประมาณ 10 ^ 10 ^ 2485766

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

การดำเนินการนี้ใช้เวลานานกว่า 5 วินาที

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

มันดึงและเชื่อมต่อความยาวไบต์ของทุกไฟล์ในไดรฟ์ปัจจุบันของคุณ Regex ดึงอักขระที่ไม่ใช่ตัวเลขออกมา

Python 3 คะแนน = 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))

ฟังก์ชั่น f คือฟังก์ชั่น ackermann ซึ่งฉันมีพื้นที่เพียงพอที่จะเรียกใช้

แก้ไข: ก่อนหน้านี้ "else n + 1" ซึ่งละเมิดกฎท้าทายความรุ่งโรจน์ของ Simply Beautiful Art

จาวาสคริปต์ 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)

สร้าง 2.718e + 239622337 ≈ 10 ↑↑ 2.9232195202

สำหรับคะแนนเพียงเล็กน้อยมากกว่า 2.718e + 239622331 ≈ 10 ↑↑ 2.9232195197

ซึ่งใหญ่ที่สุดฉันสามารถทำได้โดยไม่ต้องเบราว์เซอร์หยุดทำงาน

(console.log (a) จะแสดงผลลัพธ์ทั้งหมด)

อย่าเรียกใช้สิ่งเหล่านี้:

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)

จะส่งออก 2.718 + e121333054704 ≈ 10 ↑↑ 3.0189898069 (aka 2.718 * 10 ^ (1.213 * 10 ^ 12) เพื่อเปรียบเทียบกับคำตอบที่ยาวกว่า:

เวอร์ชั่นสุดขั้วถ้ามันไม่ทำให้เบราว์เซอร์ของคุณขัดข้อง: (80 ถ่าน)

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

ซึ่งจะสร้างตัวเลขรอบขนาดเดียวกันกับ e * 10 ^ (10 ^ 19) ≈ 10 ↑↑ 3.106786869689

แก้ไข: โซลูชันต้นฉบับของรหัสที่อัปเดตสร้างขึ้นแล้วเท่านั้น 2.718e + 464

Python 3: 98 ตัวอักษร, ≈ 10 ↑↑ 256

การใช้ฟังก์ชั่นตัวแปรอาร์กิวเมนต์:

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

อย่างมีประสิทธิภาพ E จะลดอาร์กิวเมนต์แรกในขณะที่เพิ่มอาร์กิวเมนต์ที่เหลือยกเว้นว่าแทนที่จะวาง -1 ลงในอาร์กิวเมนต์มันจะลดอาร์กิวเมนต์ลง เนื่องจากทุกรอบจะลดค่าอาร์กิวเมนต์แรกหรือลดจำนวนอาร์กิวเมนต์จึงรับประกันว่าจะยุติ ฟังก์ชั่นที่เพิ่มขึ้นใช้คือ int ("% d% d"% (k, k)) ซึ่งให้ผลลัพธ์ระหว่าง k ** 2 + 2 * k และ 10 * k ** 2 + k รหัสของฉันใช้สัญลักษณ์ * - แต่ไม่เป็นการคูณ มันใช้เพื่อทำงานกับจำนวนตัวแปรที่ขัดแย้งกันซึ่งฉันคิดว่าควรปฏิบัติตามกฎเนื่องจากจุดที่ชัดเจนของกฎคือการ จำกัด การใช้งานเฉพาะไม่ใช่ตัวสัญลักษณ์

ตัวอย่างของ E ที่มีขนาดใหญ่ขึ้นอย่างรวดเร็ว:

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)

มีเพียงสองรายการแรกเท่านั้นที่สามารถเรียกใช้บนคอมพิวเตอร์ของฉันในระยะเวลาที่เหมาะสม

จากนั้น E จะถูกเรียกใช้โดยE(*range(ord('~')))- ซึ่งหมายถึง:

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

ฉันไม่แน่ใจว่ามันใหญ่แค่ไหน (ฉันพยายามที่จะประมาณว่ามันไม่มีประโยชน์) - แต่มันชัดเจนว่ามัน ~ ใหญ่ ~ จริงๆ

ตัวอย่างเช่นประมาณสิบสองรอบผลลัพธ์จะอยู่ที่: (ในทางเทคนิคมากกว่าเล็กน้อย)

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)

การประมาณผลลัพธ์:

หากเราประมาณขั้นตอนที่เพิ่มขึ้นโดยประมาณlambda k: 10 * k**2ฟังก์ชั่นสามารถอธิบายได้ว่า

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

สิ่งที่เกี่ยวข้องที่เราทำที่นี่คือสร้างหอคอยแห่งพลังสิบดังนั้นคะแนนสุดท้ายสามารถประมาณได้ 10 ↑↑ 256

การประมาณผลลัพธ์ที่ดีขึ้น (แม้ว่าบางส่วน)

สิ่งนี้ใช้เช่นเดียว10 * k**2กับการประมาณอื่น ๆ

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

ภายใต้การประมาณการก่อนหน้านี้มันจะเป็น:

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

ซึ่งมีขนาดเล็กกว่าค่าจริงอย่างมากเนื่องจากใช้a**2แทนค่า2**aสำหรับ 10 และใช้a*2แทน2**aค่า b

C (คะแนน≈ 10 ^ 20 000 000 000 ≈ 10 ↑↑ 3.005558275)

• เอาท์พุท ~ 20 GB
• 41 ตัวอักษร (41 ^ 3 ไม่มีความหมาย)

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

แม้จะมีrand()การส่งออกจะถูกกำหนดเพราะไม่มีฟังก์ชั่นของเมล็ด