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

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

คุณอาจคิดว่า:

• จักรวาลจะตายจากเอนโทรปีใน 10 ^1,000ปี
• คอมพิวเตอร์ของคุณ:
  • จะอายุยืนจักรวาลเพราะมันทำจากUnobtainium
  • มีหน่วยความจำไม่ จำกัด / สแต็ค / จำกัด การเรียกซ้ำ
  • โปรเซสเซอร์มีความเร็ว จำกัด

คุณต้องแสดงให้เห็นว่าโปรแกรมของคุณยุติลง (ขออภัยไม่มีลูปไม่สิ้นสุด) และคำนวณเวลาทำงานที่คาดหวัง

ช่องโหว่มาตรฐานใช้

นี่เป็นความท้าทายของการเขียนโค้ดดังนั้นรหัสที่สั้นที่สุดที่ตรงตามเกณฑ์จะชนะ

แก้ไข :

น่าเสียดายที่พบ (30 นาทีต่อมา) ว่าฟิลด์ Unbtainium ของ Unobtainium รบกวนนาฬิกาภายในของคอมพิวเตอร์ทำให้ไม่มีประโยชน์ ดังนั้นโปรแกรมตามเวลาหยุดทันที (ใครจะออกจากโปรแกรมที่เพิ่งรอเป็นมรดกของมันอยู่แล้ว?)

หน่วยประมวลผลของคอมพิวเตอร์นั้นคล้ายกับ Intel i7-4578U ดังนั้นวิธีหนึ่งในการวัดเวลาทำงานก็คือรันโปรแกรมของคุณในคอมพิวเตอร์ที่คล้ายกันโดยมีอินพุตขนาดเล็กลง (ฉันหวังว่า) และคาดการณ์เวลาทำงานของมัน

แท่น

#CharsLanguageUpvotes        Author        
1    5      CJam              20       Dennis                  
2    5      J                      5         algorithmshark      
3    7      GolfScript       30       Peter Taylor          
4    9     Python             39       xnor                      
5    10   Matlab             5         SchighSchagh      

_{* โหวตวันที่ 31/08}

CJam, 5 ไบต์

0{)}h

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

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

โปรแกรมนี้จะหยุดเมื่อฮีปไม่สามารถจัดเก็บ Big Integer ได้อีกต่อไปซึ่งจะไม่เกิดขึ้นทุกเวลาบนคอมพิวเตอร์เดสก์ท็อปที่ทันสมัย

ขนาดฮีปเริ่มต้นคือ 4,179,623,936 ไบต์บนคอมพิวเตอร์ของฉัน (Java 8 บน Fedora) สามารถเพิ่มเป็นค่าใดก็ได้พร้อมด้วย-Xmxดังนั้นขีด จำกัด จริงเท่านั้นคือหน่วยความจำหลักที่มีอยู่

เวลาแห่งความตาย

สมมติว่าล่ามต้องการxบิตของหน่วยความจำในการจัดเก็บที่ไม่ใช่เชิงลบจำนวนเต็มบิ๊กน้อยกว่า2 ^xเราต้องนับถึง2 ^{8 × 4179623936} = 2 33436991488 ด้วยการเพิ่มขึ้นหนึ่งรอบต่อรอบนาฬิกาและ Core i7-3770 (3.9 GHz พร้อมเทอร์โบ) ของฉันจะใช้เวลา2 ^{33,436,991,488} ÷ 3,400,000,000,000,000> 10 ^{10,065,537,393}วินาทีซึ่งมากกว่า10 ^{10,065,537,385}ปี

JavaScript, 39

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

คำอธิบาย

ตั้งแต่ JavaScript ไม่แม่นยำแทนจำนวนเต็มขนาดใหญ่วงfor(;x!=++x;)ยุติครั้งเดียวฮิตx9007199254740992

เนื้อความของ for loop จะถูกดำเนินการFib(9007199254740992) - 1ครั้งโดยที่Fib(n)หมายเลขฟีโบนักชีที่ n

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

ดังนั้นโปรแกรมจะใช้เวลาอย่างน้อย(Fib(9007199254740992) - 1) / 150000วินาทีในการทำงาน ฉันไม่สามารถคำนวณได้Fib(9007199254740992)เพราะมันใหญ่มาก แต่ฉันรู้ว่ามันใหญ่กว่า 10 ^1,000 * 150,000

แก้ไข: ตามที่ระบุไว้ในความคิดเห็นFib(9007199254740992)ประมาณ 4.4092 * 10 ^{1882393317509686}ซึ่งมีขนาดใหญ่พอจริง

Python (9)

9**9**1e9

มันมีมากกว่า 10 ** 10,000,000 บิตดังนั้นการคำนวณมันน่าจะทำให้เราผ่านพ้นความร้อนได้

ฉันตรวจสอบว่าการดำเนินการนี้ใช้เวลานานขึ้นสำหรับค่าที่มากขึ้น แต่ก็ยังมีเหตุผลที่เหมาะสม

แก้ไข: Golfed สองตัวอักษรโดยการลบ parens ด้วย @ user2357112 TIL ที่ Python ให้เลขชี้กำลังต่อเนื่องเป็นหอคอยพลัง

GolfScript ( 12 7 ตัวอักษร)

9,{\?}*

การคำนวณและการพิมพ์ 8 ^ 7 ^ 6 ^ 5 ^ 4 ^ 3 ^ 2 ~ = 10 ^ 10 ^ 10 ^ 10 ^ 10 ^ 183230 หากต้องการพิมพ์ (ไม่ต้องคำนึงถึงการคำนวณ) ใน 10 ^ 1,000 ปี ~ = 10 ^ 1007.5 วินาทีจะต้องพิมพ์ประมาณ 10 ^ (10 ^ 10 ^ 10 ^ 183230 - 10 ^ 3) หลักต่อวินาที

Marbelous 68 66 bytes

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

Marbelous เป็นภาษา 8 บิตที่มีค่าแสดงโดยหินอ่อนในเครื่องที่เหมือน Rube Goldberg ดังนั้นนี่จึงไม่ใช่เรื่องง่าย วิธีนี้เทียบเท่ากับหลอกรหัสต่อไปนี้:

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

เนื่องจากค่าสูงสุดคือ 256 (แสดงด้วย 0 ในโปรแกรม Marbleous ซึ่งถูกจัดการแตกต่างกันในสถานที่ต่างกัน) recursiveFunction (1) จะได้รับการเรียกว่าจำนวนทั้งหมด256!*512^256เท่ากับเท่ากับ10^1200ง่ายพอที่จะอยู่รอดในจักรวาล

Marbelous ไม่มีล่ามที่รวดเร็วมากดูเหมือนว่ามันจะทำงานเกี่ยวกับการ10^11เรียกใช้ฟังก์ชั่นนี้ต่อปีซึ่งหมายความว่าเรากำลังมองหารันไทม์ของ10^1189ปี

คำอธิบายเพิ่มเติมของคณะ Marbelous

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

00เป็นตัวอักษรภาษา (หรือหินอ่อน) แสดงเป็นเลขฐานสิบหก (ดังนั้น 0) หินอ่อนนี้ตกลงไปบน--ซึ่งจะลดหินอ่อนใด ๆ ลง 1 (00 ล้อมรอบและเปลี่ยนเป็น FF หรือ 255 เป็นทศนิยม) หินอ่อนที่มีในขณะนี้ FF ค่าลงบนซึ่งผลักมันเป็นหนึ่งในคอลัมน์ทางด้านขวาบนล่าง\\ @0นี่คือพอร์ทัลและเคลื่อนย้ายหินอ่อนไปยัง@0อุปกรณ์อื่น ที่นั่นหินอ่อนวางอยู่บน/\อุปกรณ์ซึ่งเป็นนักทำสำเนาวางสำเนาหินอ่อนไว้--ทางด้านซ้ายหนึ่งชุด (หินอ่อนนี้จะวนซ้ำระหว่างพอร์ทัลและทำให้ลดลงทุกวง) และอีกอันอยู่=0ทางขวา=0เปรียบเทียบหินอ่อนกับค่าศูนย์และให้รางหินอ่อนตกลงถ้ามันเท่ากันและผลักมันไปทางขวาถ้าไม่ หากหินอ่อนมีค่า 0 มันตกลง&0มาเป็นซินโคไนเซอร์ซึ่งฉันจะอธิบายเพิ่มเติมในภายหลัง

ทั้งหมดนี้เพียงเริ่มต้นด้วยหินอ่อนมูลค่า 0 ในวงและลดลงจนกว่าจะถึง 0 อีกครั้งจากนั้นก็ใส่หินอ่อนมูลค่า 0 นี้ใน synchronizer และทำให้วนรอบในเวลาเดียวกัน

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

}0เป็นอุปกรณ์อินพุตโดยเริ่มแรกอินพุตบรรทัดคำสั่ง nth (ฐาน 0) เมื่อเรียกใช้โปรแกรมที่ได้รับในทุก}nอุปกรณ์ ดังนั้นถ้าคุณเรียกโปรแกรมนี้มีการป้อนข้อมูลบรรทัดคำสั่งที่ 2, หินอ่อน 02 }0ค่านี้จะเข้ามาแทนที่ แผ่นหินอ่อนนี้จะตกลงไปใน&0อุปกรณ์, ตัวซิงโครไนซ์ตัวอื่น, ตัว&nซิงโครไนซ์จะจับตัวเป็นหินอ่อนจนกว่า&nจะมีการยื่นคำร้องที่เกี่ยวข้อง จากนั้นหินอ่อนจะลดน้อยลงเทเลพอร์ทและทำซ้ำเหมือนในลูปที่อธิบายก่อนหน้านี้ สำเนาที่ถูกต้องจะได้รับการตรวจสอบความไม่เท่าเทียมกับศูนย์ ( >0) ถ้าไม่ใช่ 0 มันจะผ่าน ถ้าเป็น 0 มันจะถูกผลักไปทางขวาและเข้าสู่ตำแหน่ง!!ซึ่งจะยกเลิกบอร์ด

โอเคจนถึงตอนนี้เรามีการวนซ้ำที่นับถอยหลังจาก 255 เป็น 0 อย่างต่อเนื่องและให้วนซ้ำคล้ายกัน (ถูกป้อนโดยอินพุตบรรทัดคำสั่ง) วิ่งหนึ่งครั้งทุกครั้งที่มันเข้าชม 0 เมื่อวนซ้ำที่สองนี้วิ่ง n ครั้ง (สูงสุด 256 ) โปรแกรมหยุดทำงาน นั่นคือจำนวนลูปสูงสุด 65536 ครั้ง ไม่เพียงพอที่จะอยู่ได้นานกว่าเอกภพ

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

สิ่งนี้ควรเริ่มดูคุ้นเคยอินพุตจะลดลงหนึ่งครั้งจากนั้นค่านี้จะวนไปมาและคัดลอก (โปรดทราบว่าหินอ่อนจะลดลงเพียงครั้งเดียวไม่ใช่ในทุกการวิ่งของลูป) จากนั้นจะได้รับการตรวจสอบเพื่อความเท่าเทียมกัน 0 MBและถ้ามันไม่เป็นศูนย์ในดินแดน นี้เป็นฟังก์ชั่นใน Marbelous :[name]แฟ้มทุกคนสามารถมีหลายบอร์ดและคณะกรรมการแต่ละคนเป็นฟังก์ชั่นการทำงานของทุกคนจะต้องมีการตั้งชื่อโดยก่อนหน้านี้ตารางโดย ทุกฟังก์ชั่นยกเว้นฟังก์ชั่นแรกในไฟล์ซึ่งมีชื่อมาตรฐาน: MB ดังนั้นลูปนี้จะเรียกกระดานหลักอย่างต่อเนื่องอีกครั้งด้วยค่าn - 1ที่ n คือค่า teh ซึ่งอินสแตนซ์ของฟังก์ชั่นนี้ถูกเรียก

แล้วทำไมn*512ล่ะ

งั้นวงแรกวิ่งเป็น 4 เห็บ (และ 256 ครั้ง) และวงที่สองวิ่ง n ครั้งก่อนที่บอร์ดจะหยุด ซึ่งหมายความว่าบอร์ดจะทำงานเกี่ยวกับn*4*256เห็บ การวนซ้ำล่าสุด (ซึ่งการเรียกฟังก์ชันแบบเรียกซ้ำ) คือการรวบรวมและเรียกใช้ใน 2 เห็บซึ่งหมายความว่ามันจัดการเพื่อเรียกn*4*256/2 = n*512เวลาฟังก์ชั่น

สัญลักษณ์อะไรที่คุณไม่ได้พูดถึง?

\/ เป็นถังขยะซึ่งนำหินอ่อนออกจากกระดานทำให้แน่ใจว่าหินอ่อนที่ถูกแยกออกจะไม่ยุ่งกับหินอ่อนอื่น ๆ ที่วนรอบและป้องกันไม่ให้โปรแกรมหยุดทำงาน

โบนัส

เนื่องจากหินอ่อนที่ตกลงมาจากด้านล่างของบอร์ดที่น่ากลัวจะได้รับการส่งออกไปยัง STDOUT โปรแกรมนี้จะพิมพ์อักขระ ASCII จำนวนมากในขณะที่ทำงาน

Perl, 66 58 ตัวอักษร

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

ข้างต้นคือการดำเนินการของฟังก์ชั่น Ackermann-Peter ฉันไม่รู้เลยว่า A (9,9) ใหญ่แค่ไหน แต่ฉันค่อนข้างแน่ใจว่ามันจะใช้เวลาในการประเมินนานอย่างน่าประหลาดใจ

MATLAB, 58 52 ตัวอักษร

เราต้องการวิธีแก้ปัญหาทางคณิตศาสตร์ที่มีความแม่นยำอย่างน้อยหนึ่งข้อจึง:

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

x = อัน (1,999); y = x; ในขณะที่ใด ๆ (y), y = mod (y + x, ช่วงเวลา (7910)); end

( ด้วยความขอบคุณ @DennisJaheruddin สำหรับการล้ม 6 ตัวอักษร )

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

Mathematica, 25 19 ไบต์

โซลูชันนี้ถูกโพสต์ก่อนหน้าที่เวลาจะถูกตัดสิทธิ์

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

TimeUsed[]ส่งคืนวินาทีตั้งแต่เซสชันเริ่มต้นและ Mathematica ใช้ประเภทความแม่นยำโดยพลการ มี 10 ⁷วินาทีต่อปีดังนั้นการรอ 10 ^10,000วินาทีก็เพียงพอแล้ว

ทางเลือกที่สั้นกว่า (ง่ายกว่า):

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

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

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

Python 3 - 49

สิ่งนี้มีประโยชน์: คำนวณ Pi ให้แม่นยำอย่างไม่เคยปรากฏมาก่อนโดยใช้ซีรี่ส์อนันต์ของ Gregory-Leibniz

ในกรณีที่คุณสงสัยโปรแกรมนี้จะวน10**10**10**2.004302604952323ครั้ง

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

ความแม่นยำตามอำเภอใจ: 78

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

แหล่งที่มาของภาพ

ลมหายใจเทอร์มินัล

เนื่องจากมีการคำนวณจำนวนมากการ1e99**1e99ทำซ้ำจึงใช้เวลาเพียงไม่กี่1e99**1e99ปี ตอนนี้(1e99**1e99)-1e1000ทำให้แทบจะไม่แตกต่างกัน ซึ่งหมายความว่าโปรแกรมนี้จะทำงานได้นานกว่าการตายของจักรวาลของเรา

การเกิดใหม่

ตอนนี้นักวิทยาศาสตร์เสนอว่าใน10**10**56 yearsจักรวาลจะเกิดใหม่เนื่องจากความผันผวนของควอนตัมหรือการขุดอุโมงค์ ดังนั้นถ้าแต่ละจักรวาลเหมือนกันแน่นอนโปรแกรมของฉันจะมีชีวิตอยู่กี่จักรวาล?

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

สมมติว่าจักรวาลจะมีชีวิตอยู่1e10+1e1000หลายปีและใช้เวลา10**10**56หลายปีในการ 'รีบูต' โปรแกรมของฉันจะมีชีวิตอยู่ใน1e9701จักรวาล แน่นอนว่านี่คือการที่ไม่มีใครสามารถอยู่ผ่านบิ๊กแบงได้

Python 59 (ทำงานได้เกือบตลอดเวลา)

ฉันไม่สามารถต้านทาน

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

ในขณะที่ความจริงที่ว่าสิ่งนี้สามารถยุติในทางทฤษฎีภายใต้มิลลิวินาทีค่าเฉลี่ยรันไทม์ดีกว่า10^400เวลาที่ระบุอายุของจักรวาล ขอขอบคุณ @BetaDecay, @undergroundmonorail และ @DaboRoss ที่ทำให้มันมีความยาว 17 ตัวอักษร

ฉันคิดว่า J - 5 ตัวอักษร

โปรดทราบว่าทั้งหมดต่อไปนี้เป็นเลขคณิตความแม่นยำตามอำเภอใจเพราะเลข 9 นั้นมีxข้างเล็กน้อย

ในเจ็ดตัวละครเรามี!^:!!9xซึ่งเป็นเหมือนทำงาน

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

ในเลขคณิตความแม่นยำโดยพลการ นี่เกินขีด จำกัด อย่างแน่นอนเพราะSynthetica พูดอย่างนั้นดังนั้นเราจึงมีขอบเขตบน

ในหกตัวอักษรเราสามารถเขียน^/i.9xซึ่งคำนวณผลกลางของ0 ^ 1 ^ 2 ^ 3 ^ 4 ^ 5 ^ 6 ^ 7 ^ 8ทุก Wolfram | Alpha พูดว่า2^3^4^5^6^7^8เป็นประมาณ10 ^ 10 ^ 10 ^ 10 ^ 10 ^ 10 ^ 6.65185ซึ่งอาจล้างการตรวจสอบ

เรายังมีถ่านห้าตัว!!!9xซึ่งก็แค่ ((9!)!)!! W | A บอกว่ามัน10 ^ 10 ^ 10 ^ 6.2695ควรจะมีขนาดใหญ่พอ ... นั่นคือ1.6097e1859933ตัวเลขที่มีค่ามากกว่า3.154e1016จำนวนนาโนวินาทีในจักรวาล แต่ฉันจะยอมรับว่าฉันไม่รู้ว่าจะมีใครรู้ runtimes ที่แท้จริงของสิ่งเหล่านี้

แต่การพิมพ์เพียงอย่างเดียวนั้นใช้เวลานานพอที่จะยาวนานกว่าเอกภพดังนั้นมันน่าจะใช้ได้

C, 63 56 ตัวอักษร

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

สิ่งนี้มีพื้นฐานมาจากความคิดของผู้ชายที่ชื่อวิลเฮล์ม การมีส่วนร่วมอย่างเดียวของฉันคือการย่อโค้ดให้สั้นลง (และอ่านไม่ได้) ชิ้นนี้

การพิสูจน์ว่าการยกเลิกนั้นกระทำโดยการชักนำ

• ถ้า x เป็น 0 มันจะหยุดลงทันที
• ถ้ามันจบลงด้วย x-1 และ y ใด ๆ มันก็จบลงด้วย x ตัวมันเองสามารถแสดงได้โดยการเหนี่ยวนำ

การพิสูจน์ขั้นตอนการเหนี่ยวนำโดยการเหนี่ยวนำ:

• ถ้า y เป็น 0 จะมีการเรียกแบบเรียกซ้ำโดยใช้ x-1 เพียงครั้งเดียวเท่านั้นซึ่งจะยุติโดยการสันนิษฐาน
• ถ้า f (x, y-1) สิ้นสุดลงแล้ว f (x, y) ก็จะยุติลงเช่นกันเพราะการเรียกส่วนในสุดของ f คือ f (x, y-1) และการโทรนอกสุดจะสิ้นสุดลงตามการสะกดจิตเหนี่ยวนำ

เวลาทำงานที่คาดหวังคือ A (9,9) / 11837 วินาที จำนวนนี้มีตัวเลขมากกว่าจำนวนควาร์กในจักรวาลที่สังเกตได้

Matlab ( 10 8 ตัวอักษร)

1:9e1016

IMHO รายการส่วนใหญ่พยายามอย่างหนักเกินไปโดยการคำนวณสิ่งที่ใหญ่และซับซ้อน รหัสนี้จะเริ่มต้นอาร์เรย์ที่มีขนาด 9x10 ¹⁰¹⁶ doubleวินาทีนับตั้งแต่ 1 ซึ่งใช้เวลา 7.2x10 ^ ¹⁰¹⁷ไบต์ สำหรับซีพียูสมัยใหม่ที่มีแบนด์วิดท์หน่วยความจำสูงสุด21 GB / sหรือ6.63x10 ^ ¹⁷ไบต์ / ปีจะใช้เวลาอย่างน้อย 1.09x10 ^1,000ปีในการเริ่มต้นอาเรย์อย่างเดียวลองพิมพ์เพราะฉันไม่ได้รำคาญ การยับยั้งเอาต์พุตด้วยเซมิโคลอนต่อท้าย (;

โซลูชันเก่า

nan(3e508)

อีกทางเลือกหนึ่ง

inf(3e508)

รหัสนี้จะสร้างเมทริกซ์จตุรัสของNaNs / infinities ขนาด3e508x 3e508 = 9e10168-byte doubles หรือ7.2e1017bytes

Perl, 16 ตัวอักษร

/$_^/for'.*'x1e9

สิ่งนี้จะสร้างสตริงซ้ำ ". *" หนึ่งพันล้านครั้งจากนั้นใช้มันเป็นทั้งเข็มและกองหญ้าในการแข่งขัน regex ในทางกลับกันสิ่งนี้ทำให้เอ็นจิน regex พยายามทุกพาร์ติชันที่เป็นไปได้ของสตริงที่มีความยาวสองพันล้านอักขระ ตามสูตรนี้จาก Wikipediaมีพาร์ติชั่นดังกล่าวประมาณ 10 ³⁵²¹⁸

วิธีแก้ปัญหาข้างต้นมีความยาว 16 ตัวอักษร แต่ต้องการหน่วยความจำประมาณ 2Gb เท่านั้นซึ่งหมายความว่าสามารถใช้งานได้บนคอมพิวเตอร์จริง หากเราสมมติว่ามีหน่วยความจำไม่สิ้นสุดและขนาดการลงทะเบียนที่ จำกัด (ซึ่งอาจไม่สมเหตุสมผล) ก็สามารถทำให้สั้นลงได้ถึง 15 ตัวอักษรในขณะที่เพิ่มเวลารันไทม์อย่างมาก:

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

(ฉันยังไม่ได้ทดสอบ แต่ฉันคิดว่ามันสามารถทำงานกับ Perl 32 บิตที่สร้างขึ้นบนเครื่อง 64 บิตพร้อม RAM อย่างน้อย 6Gb)

หมายเหตุ:

• x เป็นตัวดำเนินการสตริงซ้ำ
• forไม่ได้เป็นห่วงจริง มันใช้เพื่อบันทึกอักขระหนึ่งตัวเท่านั้น (เปรียบเทียบกับ$_=".*"x1e9;/$_^/)
• ^regex สุดท้ายใน regex ทำให้แน่ใจได้ว่าเฉพาะสตริงว่างเท่านั้นที่สามารถจับคู่ได้ เนื่องจากค่าเริ่มต้นของ regex นั้นเป็นสิ่งที่โลภมากและนี่เป็นสิ่งสุดท้ายที่เครื่องยนต์จะลอง
• การวัดประสิทธิภาพในคอมพิวเตอร์ของฉันสำหรับค่า (1..13) แนะนำว่าเวลาทำงานคือ O (exp (n)) ซึ่งมากกว่า O (exp (sqrt (n))) ในสูตร Wikipedia

J (12)

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

สิ่งนี้เกิดขึ้นใน Python (สมมติว่า!ทำงานได้):

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

แก้ไข:

โปรแกรมสามารถใช้เวลาไม่เกิน2 × 10^-1858926วินาทีต่อรอบเพื่อให้เสร็จสิ้นภายในเวลาที่กำหนด เคล็ดลับ: สิ่งนี้จะไม่ทำงานในรอบแรกไม่ต้องคำนึงถึงรอบสุดท้าย;)

นอกจากนี้โปรแกรมนี้อาจต้องการหน่วยความจำมากกว่าที่มีเอนโทรปีในจักรวาล ...

C # 217

ฉันไม่ใช่นักกอล์ฟ แต่ฉันไม่สามารถต้านทานการทำงานของ Ackermanได้ ฉันไม่รู้วิธีคำนวณ runtime แต่มันจะหยุดแน่นอนและมันจะทำงานได้นานกว่าเวอร์ชั่นนี้แน่นอน

class P{
static void Main(){for(int i=0;i<100;i++){for(int j=0;j<100;j++){Console.WriteLine(ack(i,j));}}}
static int ack(int m,int n){if (m==0) return n+1;if (n ==0) return ack(m-1,1);return ack(m-1,ack(m,n-1));}
}

ความพยายามครั้งแรกที่โค้ดกอล์ฟ แต่นี่จะไป

VBA - 57 45

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

ดังนั้น X จะเพิ่มขึ้นทีละหนึ่งหากเหตุการณ์ 1 ใน 2 ^ 128 เกิดขึ้นและรีเซ็ตหากไม่เกิดขึ้น รหัสจะสิ้นสุดเมื่อเหตุการณ์นี้เกิดขึ้น 2 ^ 64 + 1 ครั้งติดต่อกัน ฉันไม่รู้จะเริ่มคำนวณเวลาได้อย่างไร แต่ฉันคิดว่ามันใหญ่มาก

แก้ไข: ฉันคำนวณคณิตศาสตร์และความน่าจะเป็นที่จะเกิดขึ้นในแต่ละลูปคือ 1 ใน 2 ^ 128 ^ (1 + 2 ^ 64) ซึ่งมีความยาวประมาณ 20,000 หลัก สมมติว่า 1000000 loops / วินาที (ballpark จากจำนวน air thin) และ 30000000 s / yr นั่นคือ 3 * 10 ^ 13 รอบต่อปีเวลา 10 ^ 1000 ปีที่เหลืออยู่คือ 3 * 10 ^ 1013 รอบดังนั้นสิ่งนี้น่าจะอยู่ที่ประมาณ 20 ครั้ง เวลาที่เหลืออยู่ในจักรวาล ฉันดีใจที่คณิตศาสตร์ของฉันสำรองปรีชาญาณของฉัน

C, 30 ตัวอักษร

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

สมมติว่าคำชมของทั้งสองลงนามล้นและ int 32- บิตนี่จะทำงานประมาณ 2 ^{2 32}ฟังก์ชั่นการโทรซึ่งน่าจะมีเวลาเหลือเฟือที่จักรวาลจะจบ

GolfScript 13 ตัวอักษร

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

โปรแกรมนี้เพียงแค่นับขึ้น 0-10 ^{9 9 -1} = 10 387420488 สมมติว่าในแง่ดีว่าคอมพิวเตอร์ทำงานที่ 100 GHz และสามารถดำเนินการซ้ำของโปรแกรมในรอบเดียวโปรแกรมจะทำงานเป็นเวลา 10 ^{9 9 912}วินาทีหรือประมาณ 3 × 10 ^{9 9 −20} = 3 × 10 ^387420469ปี.

เพื่อทดสอบโปรแกรมคุณสามารถแทนที่9ด้วย a 2ซึ่งจะทำให้หยุดที่ 10 ^{2 2 −1} = 10 ³ = 1,000 (การใช้ a 3แทน2จะทำให้หยุดที่ 10 ^{3 3 −1} = 10 ²⁶ซึ่ง แม้ว่าจะมีสมมติฐานในแง่ดีข้างต้น แต่ก็ไม่สามารถเข้าถึงได้อย่างน้อยสองสามล้านปี)

Autohotkey 37

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

Haskell, 23

main=interact$take$2^30

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

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

~ ATH, 56

ในภาษาสมมติ ~ ATH :

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

~ ATH เป็นภาษาที่ใช้งานไม่ได้ ตรรกะของมันประกอบด้วยอะไร แต่ไม่มีที่สิ้นสุดลูปหรือที่ดีที่สุดคือลูปของการก่อสร้างที่ไม่มีที่สิ้นสุดอย่างมีประสิทธิภาพ

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

ฉันขอโทษสำหรับการละเมิดช่องโหว่ชายแดน ฉันคิดว่ามันเกี่ยวข้องเกินกว่าจะผ่านไปได้

หากใครถูกขบขันด้วยสิ่งนี้จริง ๆ รายละเอียดเพิ่มเติม: (1) , (2) , (3) , (4)

ทับทิม (34)

สาย([0]*9).permutation.each{print}ใช้เวลาประมาณ 2.47 วินาทีเป็นเวลา 9! พิมพ์บนเครื่องของฉันในขณะที่บรรทัด([0]*10).permutation.each{print}ใช้เวลาประมาณ 24.7 วินาทีนาน 10! พิมพ์ดังนั้นฉันคิดว่าฉันสามารถคาดการณ์ที่นี่และคำนวณ(24.7/10!)*470! seconds in yearsว่าเป็น 6.87 * 10 ^ 1040 ซึ่งควรเป็นเวลาทำงานของ:

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

JavaScript 68 62 ตัวอักษร

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

สิ่งนี้ใช้ฟังก์ชัน Ackermannซึ่งสามารถเขียนเป็น

function ackermann(a, b) {
  if (a == 0) return b + 1;
  if (b == 0) return ackermann(a-1, 1);
  else return ackermann(a-1, ackermann(a, b-1));
}

เวลารันไทม์ของมันเพิ่มขึ้นเป็นทวีคูณและใช้เวลานานมากในการคำนวณ แม้ว่าจะไม่ใช่ภาษาอังกฤษที่นี่คุณสามารถรับภาพรวมของค่าส่งคืน ตามตารางackermann(5,1)เท่ากับ2↑↑(65533)-3ซึ่งคุณรู้ว่าใหญ่มาก

Befunge '93 - 40 ไบต์

(โปรแกรม 20x2)

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

โปรแกรมนี้อาศัยตัวเลขสุ่มเพื่อให้เกิดความล่าช้า เนื่องจากล่าม Befunge ค่อนข้างช้าโปรแกรมนี้จึงควรเก็บเงิน และหากไม่เป็นเช่นนั้นเราก็สามารถขยายได้ในแนวนอนเสมอ ฉันไม่แน่ใจว่าจะคำนวณเวลาทำงานของโปรแกรมนี้ได้อย่างไร แต่ฉันรู้หรือไม่ว่า มีโอกาส 50/50 ในการเริ่มต้นใหม่หรือเปลี่ยนตำแหน่งแนวนอนด้วย 1 มี 18 หรือไม่ ฉันคิดว่ามันควรจะเป็นบางสิ่งบางอย่างตามแนว (18 ^ 2)! ซึ่งเครื่องคิดเลขของ Google บอกว่าเป็น "Infinity"

แก้ไข: อ้าวฉันไม่ได้สังเกตเห็นคำตอบ Befunge อื่น ๆ นี่คือการโพสต์ครั้งแรกของฉันที่นี่ ขอโทษ

APL, 10

ฉันไม่คิดว่านี่เป็นคำตอบที่ถูกต้อง (เพราะไม่ใช่แบบไม่แน่นอน) แต่ทว่า ......

{?⍨1e9}⍣≡1

โปรแกรมนี้คำนวณการเรียงสับเปลี่ยนแบบสุ่มของตัวเลข 1e9 ( ?⍨1e9) และทำซ้ำจนกว่าเอาต์พุตต่อเนื่องสองรายการจะเท่ากัน ( ⍣≡)

ดังนั้นทุกครั้งที่มีการคำนวณการเรียงสับเปลี่ยนมันจะมี 1 ใน 1000000000! โอกาสในการยกเลิก และ 1000000000! เป็นเวลาอย่างน้อย 10 ¹⁰ 8

เวลาที่ใช้ในการคำนวณการเรียงสับเปลี่ยนนั้นไม่เกี่ยวข้องกับความหนาแน่นของ 1000000000! แต่การทดสอบแสดงให้เห็นว่านี่คือการO(n)คาดการณ์และให้ประมาณ 30 วินาที

อย่างไรก็ตามล่ามของฉันปฏิเสธที่จะรับอินพุตไปยังฟังก์ชั่นแบบสุ่มที่มีขนาดใหญ่กว่า 2 ³¹ 1 (ดังนั้นฉันจึงใช้ 1e9) และการสร้างการเรียงสับเปลี่ยนจำนวน 1000000000 หมายเลขทำให้เกิดข้อผิดพลาดในพื้นที่ทำงาน อย่างไรก็ตามแนวคิดสามารถทำได้ด้วยล่าม APL ที่เหมาะกับหน่วยความจำที่ไม่มีที่สิ้นสุด

สิ่งนี้ทำให้เรามีความเป็นไปได้ที่จะใช้ 2 ⁶³ -1 แทน 1e9 เพื่อชนเวลาทำงานอย่างน้อย 10 ^{10 20}โดยสมมติว่าเป็นสถาปัตยกรรม 64 บิต

แต่เดี๋ยวก่อนสถาปัตยกรรมเกี่ยวข้องกับล่ามในอุดมคติหรือไม่? นรกไม่มีจริง ๆ แล้วไม่มีขอบเขตบนเวลาทำงาน !!

R, 45 ไบต์

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

มันเป็นหัวข้อเก่า แต่ฉันไม่เห็นคำตอบ R และเราไม่สามารถมีมันได้!

รันไทม์สำหรับฉันคือประมาณ 1 วินาทีเมื่อ x คือ 20 แนะนำให้รันไทม์เป็น 2 ^ 9979 วินาที

หากคุณแทนที่ค่าศูนย์ด้วยค่าหนึ่งผลลัพธ์จะเป็น 2 ^ x แต่เนื่องจากมันแทนผลลัพธ์ที่ได้คือศูนย์ใด ๆ ก็ตามที่ x คือ (เพื่อหลีกเลี่ยงปัญหาโอเวอร์โฟลว์)

Javascript, 120 ไบต์

a=[0];while(a.length<1e4)(function(){var b=0;while(b<a.length){a[b]=(a[b]+1)%9;if(a[b])return;b++}a.push(1)})();alert(a)

สามารถทำได้ด้วยหน่วยความจำน้อยที่สุด (อาจน้อยกว่าครึ่งเมกะไบต์) แต่ใช้เวลา (อาจ) ประมาณ 10 ^8,750ปีเพื่อหยุด

ซ้ำ ๆ เพิ่มขึ้นเล็กน้อย-endian ฐาน-9 BigInteger จนกว่าจะถึง 9 ^{10 4} -1

Python 3, 191 ไบต์

from random import*
r=randint
f=lambda n:2if n<2else f(n-1)
x=9E999
s=x**x
for i in range(f(x)**f(s)):
 while exec(("r(0,f(x**i))+"*int(f(x)))+"r(0,f(x**i))")!=0:
  s=f(x**s)
  print(s)

ก่อนอื่น f คือฟังก์ชันแฟกทอเรียลแบบเรียกซ้ำและช้ามาก จากนั้นจะมีตัวต่อ 9 * 10owed ซึ่งสร้าง OverflowError แต่สิ่งนี้ไม่ได้เกิดขึ้นในคอมพิวเตอร์ Unobtanium For-Loop วนซ้ำ 9E999! ^ (9E999 ^ 9E999)! ครั้งและจะไปที่การทำซ้ำครั้งถัดไปถ้า 9E999! +1 ints แบบสุ่มระหว่าง 0 ถึง 9E99 * ^ i! ทั้งหมด 0 และในทุกการวนซ้ำของ while-loop s ได้รับการตั้งค่าเป็น (9E999 ^ s)! เอ่อฉันลืมไปว่าการพิมพ์ของ s ต้องใช้เวลา muuuuccchhhh ...
ฉันรู้ว่ามันไม่ใช่คำตอบสั้นที่สุด แต่ฉันคิดว่ามันมีประสิทธิภาพจริงๆ มีคนช่วยฉันคำนวณเวลาทำงานได้ไหม

เครื่องจักรทัวริง แต่แย่กว่า 167 ไบต์

0 0 1 1 2 0 0
1 0 1 0 4 0 0
0 1 1 1 2 0 0
1 1 1 1 5 0 0
0 2 1 0 3 0 0
1 2 0 1 1 0 0
0 3 1 1 4 0 0
1 3 0 0 2 0 0
0 4 1 0 0 0 0
1 4 0 1 3 0 0
0 5 1 0 6 0 1
1 5 1 1 2 0 0

ลองออนไลน์!

ควรใช้ 6 รัฐ 2 สัญลักษณ์ช่องคลอดไม่ว่างจากหน้าวิกิพีเดีย

$7.412 \times 10^{36534}$