อันนี้ค่อนข้างเรียบง่าย

เขียนโปรแกรมที่สั้นที่สุดที่คุณสามารถทำได้ในขณะที่สร้างผลลัพธ์มากที่สุด

เพื่อให้สนุกโปรแกรมที่สร้างเอาต์พุตไม่สิ้นสุดจะถูกตัดสิทธิ์

ผู้ชนะคือโปรแกรมที่มีขนาดเอาต์พุต / อัตราส่วนขนาดโค้ดใหญ่ที่สุด

ผลลัพธ์ขึ้นอยู่กับสิ่งที่ใช้งานได้บนคอมพิวเตอร์ของฉันซึ่งเป็น Mac ที่ใช้ Mac OS X 10.7.5 พร้อมด้วยหน่วยความจำ Intel Core i5 และ 8GB

Python: 8 chars code, 387420489 chars output - อัตราส่วน: 48427561.125: 1

'a'*9**9

เราสามารถมีอัตราส่วนแนวโน้มที่จะไม่มีที่สิ้นสุดโดยการเพิ่ม**9s:

'a'*9**9**9
'a'*9**9**9**9
etc.

ตัวอย่างเช่น:

'a'*9**9**9**9**9**9

ซึ่งมีอัตราส่วนของ~ 10 ^{10 10 10 10 8.568} (จำนวนมากเหลือล้น)

ดังนั้นทั้งหมดนี้เป็นโปรแกรมที่ดีที่ให้ผลผลิตจำนวนมากโดยมีโค้ดน้อยมาก แต่ไม่มีโปรแกรมใดที่สั้นจริงๆ ...

brainfuck, 5 ตัวอักษร, 255 ไบต์ของเอาต์พุต

-[.-]

ฉันคิดว่านี่เป็นกรณีใช้งานเพียงอย่างเดียวที่ brainfuck เก่งจริงๆ ฉันรู้ว่าอันนี้จะไม่ชนะ แต่ฉันไม่คิดว่าเราจะทำได้ดีกว่าตัวอย่างของ Python ไม่เพียงแค่นั้น แต่ ...

brainfuck, 4 ตัวอักษร, เอาต์พุตไม่ จำกัด

-[.]

ฉันคาดเดาว่านี่เป็นโปรแกรมอินพุทไม่สิ้นสุดที่สั้นที่สุด

จริงๆแล้วเพื่อน ๆ ของฉันเพิ่งจะมาพร้อมกับสิ่งที่ดีจริงๆ

Python 80 ไบต์จำนวนเอาต์พุตที่ไม่รู้จัก

from datetime import datetime
while datetime.now()!=datetime.max()
 print "This will probably get disqualified"

โปรแกรมนี้จะหยุดในที่สุดแน่นอน แต่จะทำหลังจากผ่านไปประมาณ 8,000 ปีเท่านั้น จำนวนอักขระที่แน่นอนจะขึ้นอยู่กับอัตราที่คอมพิวเตอร์ของคุณสามารถสร้างอักขระได้

Perl - เอาต์พุต 19 ไบต์, 187200000000000000 ไบต์ไบต์ (9852631578947368.42: 1)

print+($]x9e7)x26e7

166 เพตาบายพร้อมคำสั่งพิมพ์เดียวโดยใช้หน่วยความจำไม่เกิน 1.7GB

มีบางสิ่งที่ทำให้ความท้าทายนี้น่าสนใจยิ่งกว่าที่ฉันคิดไว้ Perl ดูเหมือนว่าจะปฏิเสธที่จะจัดสรรหน่วยความจำมากกว่า 1GB ให้กับรายการใด ๆ ดังนั้นการอ้างอิงสเกลาร์ขนาด 4 ไบต์กับสตริงภายในอาจทำซ้ำได้26e7 ≈ 2 ²⁸ครั้ง $]คือหมายเลข 'เวอร์ชัน perl เก่า' ซึ่งเป็นสตริงมีความยาว 8 ไบต์คล้าย5.016002กัน

ด้วยหน่วยความจำระบบมากขึ้นก็ควรจะสูงขึ้น สมมติว่า 8GB เต็มจริงพร้อมใช้งานคุณควรจะสามารถใช้$]x9e8สำหรับสตริงภายในแทนซึ่งจะส่งออก 1.62 Exabytes

Ruby และ Python, 13 chars, 599994 char output, อัตราส่วน ~ 46153: 1

999999**99999

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

(ฉันทำสิ่งนี้ก่อนหน้านี้ขณะนี้ฉันกำลังทำงานเกี่ยวกับการวนซ้ำเพื่อให้ได้ผลลัพธ์ที่ยาวขึ้น)

แก้ไข: ฉันทำมัน!

Ruby, 28 ตัวอักษร, เอาต์พุต 6e599999 ถ่าน, อัตราส่วน ~ 6e599998 (ฉันคิดว่า)

a=999999**99999;a.times{p a}

ยังไม่ได้ทดสอบ (สำหรับเหตุผลที่ชัดเจน) แต่ฉันค่อนข้างแน่ใจว่าหมายเลขแรกมีค่าประมาณ 1e599994 ซึ่งคูณด้วย 599994 คือประมาณ 6e599999 ในทางทฤษฎีมันจะใช้งานได้ แต่ฉันไม่แน่ใจว่ามันจะทำให้คอมพิวเตอร์ของคุณเสียหายหรือไม่ดังนั้นข้อจำกัดความรับผิดชอบ: ฉันไม่รับผิดชอบหากมันเป็นอันตรายต่อคอมพิวเตอร์ของคุณในทางใดทางหนึ่ง: P

แน่นอนคุณสามารถไปต่อได้:

Ruby, 37 chars, 6e359992800041 char output, ~ 6e359992800040 อัตราส่วน

a=999999**99999;a.times{a.times{p a}}

แต่ฉันสงสัยว่าคอมพิวเตอร์เครื่องใดสามารถจัดการกับสิ่งนั้นได้: หน้า

หากอนุญาตให้อินพุตไม่สิ้นสุด

cat /dev/random

เนื่องจากไม่ใช่

head -99 /dev/random

(เอาต์พุต 25128: 20 อินพุต = 1256.4: 1)

ฉันไม่ได้อยู่ในกล่อง Linux แต่ฉันคิดว่าคุณสามารถทำอะไรบางอย่างได้

timeout 99d cat /dev/random

และได้รับผลลัพธ์มาก (ผ่านการตอบสนองของ GigaWatt)

HQ9 +, 11471

9

จำนวนตัวอักษรที่แท้จริงจะแตกต่างกันไปขึ้นอยู่กับล่าม แต่ประมาณ 10,000 อาจจะใช่มั้ย

C #: 108 ตัวอักษร อัตราส่วน: 742123445489230793057592: 1

for(ulong i=0;i<ulong.MaxValue;i++){Console.Write(new WebClient().DownloadString(@"http://bit.ly/dDuoI4"));}

เพียงดาวน์โหลดและพิมพ์รายชื่อเสมียนกฎหมายของศาลฎีกาของสหรัฐอเมริกา (4344904 ตัวอักษร) 18446744073709551615 ครั้ง

~ - ~! - อัตราส่วน: (64 ^{4 4 4 64} ) / 154 ~ = 10 ^{10 10 10 10 1.583328920493678}

'=~~~~,~~~~,~~~~:''=|*<%[%]'=',',',':''&*-~|:'''=|*<%[%]''&',',',':'''&*-~|:''''=|*<%[%]'''&',',',':''''&*-~|:''''&':''=|*<%[%]@~~~~,~~~~,~~:''&*-~|:''&':

วิธีการทำงาน: ขั้นแรกตั้งค่า'เป็น 4 ^ 3 หรือ 64 จากนั้นจะสร้าง''ฟังก์ชันที่ตั้งค่า'เป็น'^ 4 * คูณครั้ง '''ทำฟังก์ชั่นที่เรียกใช้''กับอินพุตเป็น'^ 4 จากนั้น''''ทำฟังก์ชั่นที่เรียก'''ด้วย'^ 4 เนื่องจากเป็นอินพุต ''''ถูกเรียกใช้ด้วยอินพุต 64 ในที่สุด''เปลี่ยนเป็นฟังก์ชันที่พิมพ์เว้นวรรค * ครั้ง; 'นี้ก็จะเรียกว่ามีการป้อนข้อมูลของ

ปรากฎออกมาในท้ายที่สุดแล้ว'เป็น 64 ^{4 4 4 64}และความยาวโปรแกรมของฉันคือ154 ; เจาะเข้าไปใน Wolfram | Alphaและมันแยกออก10 ^{10 10 10 10 1.583328920493678}ซึ่งมันไม่ได้รบกวนการคำนวณ ฉันไม่รู้ด้วยซ้ำว่ามีกี่หลักแต่ 64 ^{4 4}มี 463 ค่อนข้างดีสำหรับภาษาที่รองรับเฉพาะตัวเลขที่ไม่ชัดเจนและไม่มีฟังก์ชันเลขชี้กำลัง 3

ฉันสามารถทำให้สิ่งนี้ใหญ่กว่านี้ได้ แต่มากไป

Javascript: 27 ตัวอักษร; ถ่านเอาท์พุท 260,431,976 ถ่าน; อัตราส่วน 9,645,628.74

for(s=i=61;s=btoa(s),i--;)s

รหัสนี้เข้ารหัสการป้อนข้อมูลซ้ำ61ถึง Base64 61 ครั้ง การเข้ารหัสอินพุตความยาวใด ๆnไปยัง Base64 จะสร้างเอาต์พุตของความยาวn * 8/6โดยปัดขึ้นเป็นทวีคูณของ 4

นี้จะต้องเรียกใช้จากสภาพแวดล้อม JavaScript คอนโซลที่ natively btoaสนับสนุนฟังก์ชั่น (เบราว์เซอร์ที่ทันสมัยใด ๆ แต่ไม่ Node.js. ) หมายเหตุ Chrome สามารถไม่ทำงานสูงกว่าi=61ในขณะที่ Firefox i=60เท่านั้นสามารถเข้าถึง โปรดทราบว่าคอนโซลของ Chrome ไม่สามารถแสดงผลได้จริงเพราะมีขนาดใหญ่เกินไป แต่คุณสามารถตรวจสอบขนาดผลลัพธ์ได้ด้วยการเรียกใช้

for(s=i=61;s=btoa(s),i--;)s.length

หากโปรแกรมนี้ได้รับอนุญาตให้ทำงานได้มากที่สุดi=99ก็จะสร้างผลลัพธ์ขนาด14,566,872,071,840 (14.5 ล้านล้าน, 14.5e12) ขนาด14,566,872,840สำหรับสมมุติฐานอัตราส่วนประมาณ 540 ล้าน (5.39e11)

Ruby, 23 ตัวอักษร - ~ 500000000000000 (5e14) เอาต์พุต

while rand
puts 0
end

Ti-Basic 84, 13 ตัวอักษร - ~ 3000 เอาต์พุต

:Disp 1
:prgmA

ตั้งชื่อโปรแกรม prgmA

ทับทิม283 96 44 ตัวอักษร

a=1e99.times;a{a{a{a{a{puts'a'*99}}}}}}}}}}

ไม่สั้นมาก แต่ชดเชยให้มันออกมาซึ่งมากฉันยังไม่สามารถวัดได้

Mathematica 9 chars อัตราส่วน: ~ 4564112: 1

ต่อไปนี้เป็นรูปภาพของอินพุต Mathematica ฉันไม่ได้คิดวิธีการแสดงใน SE

นี่คือภาพหน้าจอที่แสดงจำนวนหลักในผลลัพธ์ IntegerDigitsแปลงเอาต์พุตเป็นรายการของตัวเลข Lengthนับจำนวนหลัก

การกดแป้นพิมพ์เพื่อป้อน: 9, ctrl6, 9, ctrl6, 9, ctrl6, 9, ctrl6, 9....

Befunge-93: 48 ตัวอักขระเอาต์พุต (ประมาณ (2 ^ 32) ^ 2) * 10 ตัวอักษร *

สแต็กของ Befunge นั้นไม่มีที่สิ้นสุดทางทฤษฎี แต่ตัวเลขที่สแต็คสโตร์นั้น จำกัด อยู่ที่ขนาดของจำนวนเต็มแบบยาวที่ไม่ได้ลงนาม (ที่นี่จะเป็น 32 บิต) ดังนั้นสำหรับล่าม Befunge, (x + 1)> x จึงเป็นเท็จสำหรับค่าที่เหมาะสมของ x เราใช้ข้อเท็จจริงนี้เพื่อผลักดันค่าทั้งหมดจากศูนย์ถึงค่าสูงสุด (สองครั้งโดยมีหนึ่งค่าทุก ๆ สามหมายเลข) จากนั้นสำหรับแต่ละค่าบนสแต็กเราส่งออกและลดค่าลงจากนั้นป๊อปอัพ ในที่สุด stack เปล่าและโปรแกรมจะสิ้นสุดลง ฉันอาจจะขนาดบิตออกเล็กน้อย แต่ควรจะอยู่ที่ไหนสักแห่งใน ballpark ที่

>::1# + #1\`# :# _> #- #1 :# :# .# _# .# :# _@

C: 48 ตัวอักษรประมาณ (2 ^ 32 - 1) * เอาต์พุต 65090 ไบต์

main(){for(int i=1<<31;i<~0;)puts("!");main();}

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

java (131): ไม่ทราบจำนวนที่แน่นอน

class A{public static void main(String[] args){while(Math.random()>0){for(long l=0;l!=-1;l++){System.out.println("1234567890");}}}}

ใช้โอกาสที่ต่ำของ Math.random () เพื่อไปที่ 0 ในลูปจากนั้น goin 2 ^ 64-1 ลูปผ่าน foreach ด้วยเอาต์พุต 1234567890

Python 3, 115 ไบต์ทำงานเป็นเวลา 7983 ปี (ไม่ทราบจำนวนตัวอักษร)

แก้ไข: ymbirtt เอาชนะฉันมัน

ฉันรู้ว่ามันไม่ได้สั้นมากและฉันรู้ว่าคำตอบอื่น ๆ ของ Python นั้นยาวกว่านี้มากแต่ฉันตัดสินใจที่จะให้ช็อตนี้

โปรแกรมนี้ทำงานมาประมาณ 8,000 ปีซึ่งอย่างที่คุณรู้ว่าเป็นเวลานานพอสมควร

สิ่งที่มันคือการได้รับเวลาปัจจุบันอย่างต่อเนื่องโดยใช้datetime.datetime.now()ฟังก์ชั่นและมันเปรียบเทียบกับ9999-12-31 24:59:59.999999ซึ่งเป็นเท่าที่ฉันรู้วันที่สูงสุดในงูหลาม

ถ้าจะเป็นเท่ากันโปรแกรมหยุด aถ้ามันไม่ได้ก็ต่อเนื่องเอาท์พุท

import datetime
while 1:
    if str(datetime.datetime.now())=="9999-12-31 24:59:59.999999":exit
    else:print("a")