Điều này là khá đơn giản.

Viết chương trình ngắn nhất bạn có thể, trong khi tạo ra nhiều đầu ra nhất.

Để làm cho nó vui, các chương trình tạo ra đầu ra vô hạn sẽ bị loại.

Người chiến thắng là chương trình có tỷ lệ kích thước / kích thước mã đầu ra lớn nhất.

Kết quả dựa trên những gì hoạt động trên máy tính của tôi , đó là máy Mac chạy Mac OS X 10.7.5 với bộ nhớ Intel Core i5 và 8GB.

Python: mã 8 ký tự, đầu ra 387420361 - Tỷ lệ: 48427561.125: 1

'a'*9**9

Chúng ta có thể có tỷ lệ có xu hướng vô cùng bằng cách thêm nhiều **9s:

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

Ví dụ:

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

có tỷ lệ ~ 10 ^{10 10 10 10 8,568} (số lượng lớn không thể tưởng tượng được).

Vì vậy, đây đều là những chương trình tốt tạo ra nhiều đầu ra với rất ít mã, nhưng không có chương trình nào thực sự ngắn ...

brainfuck, 5 ký tự, 255 byte đầu ra

-[.-]

Tôi nghĩ rằng đây là trường hợp sử dụng duy nhất mà brainfuck thực sự vượt trội. Tôi biết điều này sẽ không chiến thắng, nhưng tôi không nghĩ chúng ta có thể làm tốt hơn ví dụ Python. Không chỉ vậy mà...

brainfuck, 4 ký tự, đầu ra vô hạn

-[.]

Tôi phỏng đoán rằng đây là chương trình đầu ra vô hạn ngắn nhất ngoài kia.

Trên thực tế, chờ đã, người bạn đời của tôi đã nghĩ ra một điều thực sự tốt.

Python, 80 byte, lượng đầu ra không xác định

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

Chương trình này chắc chắn sẽ dừng lại cuối cùng, nhưng sẽ chỉ làm như vậy sau khoảng 8.000 năm. Số lượng ký tự đầu ra chính xác phụ thuộc vào tốc độ máy tính của bạn có thể tạo ký tự.

Perl - 19 byte, đầu ra 187200000000000000 byte (9852631578947368.42: 1)

print+($]x9e7)x26e7

166 petabyes với một câu lệnh in duy nhất, sử dụng bộ nhớ không quá 1,7 GB.

Có một vài điều làm cho thử thách này trở nên thú vị hơn mà tôi nghĩ nó sẽ xảy ra. Perl dường như từ chối phân bổ hơn 1GB bộ nhớ cho bất kỳ danh sách nào. Do đó, tham chiếu vô hướng 4 byte cho chuỗi bên trong chỉ có thể được lặp lại 26e7 ≈ 2 ²⁸ lần. $]là số 'phiên bản perl cũ', như một chuỗi, dài 8 byte, giống như 5.016002.

Với bộ nhớ hệ thống nhiều hơn, nó sẽ có thể tăng cao hơn. Giả sử 8GB đầy đủ thực sự có sẵn, bạn sẽ có thể sử dụng $]x9e8cho chuỗi bên trong, thay vào đó sẽ tạo ra 1,62 exabyte.

Ruby và Python, 13 ký tự, sản lượng char 599994, tỷ lệ ~ 46153: 1

999999**99999

Đơn giản chỉ cần tăng một số lượng rất lớn lên sức mạnh của một số rất lớn khác. Mất khoảng 20 giây để chạy. Tôi không thể tăng số vì điều đó sẽ khiến số đó trở thành Vô cực.

(Tôi đã làm điều này sớm hơn , tôi hiện đang làm việc để tạo một vòng lặp cho đầu ra thậm chí lâu hơn)

Chỉnh sửa: Tôi đã làm nó!

Ruby, 28 ký tự, sản lượng char 6e599999, tỷ lệ ~ 6e599998 (tôi nghĩ)

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

Chưa được kiểm tra (vì lý do rõ ràng), nhưng tôi khá chắc chắn rằng số đầu tiên là khoảng 1e599994, nhân với 599994 là khoảng 6e599999. Về mặt lý thuyết nó sẽ hoạt động, nhưng tôi không chắc liệu nó có làm sập máy tính của bạn không, vì vậy hãy từ chối: Tôi không chịu trách nhiệm nếu nó làm hại máy tính của bạn theo bất kỳ cách nào: P

Tất nhiên, bạn có thể tiếp tục:

Ruby, 37 ký tự, đầu ra 6e359992800041 char, tỷ lệ ~ 6e359992800040

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

Và như vậy, nhưng tôi nghi ngờ bất kỳ máy tính có thể xử lý đó: P

Nếu đầu vào vô hạn được cho phép,

cat /dev/random

Vì nó không phải là,

head -99 /dev/random

(Đầu ra 25128: 20 đầu vào = 1256,4: 1)

Tôi không dùng Linux, nhưng tôi tưởng tượng bạn có thể làm gì đó như

timeout 99d cat /dev/random

và nhận được một sản lượng lớn. (thông qua phản hồi của GigaWatt)

HQ9 +, 11471

9

Số lượng nhân vật thực tế khác nhau tùy thuộc vào người phiên dịch, nhưng có lẽ khoảng 10000 sẽ đúng?

C #: 108 ký tự. Tỷ lệ: 742123445489230793057592: 1

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

Nó chỉ tải xuống và in Danh sách thư ký luật của wikipedia của Tòa án Tối cao Hoa Kỳ (4344904 chars) 18446744073709551615 lần.

~ - ~! - Tỷ lệ: (64 ^{4 4 4 64} ) / 154 ~ = 10 ^{10 10 10 10 1.583328920493678}

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

Cách thức hoạt động: Đầu tiên, nó đặt 'thành 4 ^ 3 hoặc 64. Sau đó, nó tạo ''một hàm đặt 'thành '^ 4 * lần (trong đó * là đầu vào). '''sau đó được tạo một hàm gọi ''với đầu vào là '^ 4. Sau đó, ''''được thực hiện một chức năng trong đó kêu gọi '''với '^ 4 vì nó của đầu vào. ''''sau đó được gọi với đầu vào là 64. Cuối cùng, ''được thay đổi thành hàm in một khoảng trắng * lần; điều này sau đó được gọi với một đầu vào của '.

Hóa ra, cuối cùng, 'là 64 ^{4 4 4 64} , và độ dài chương trình của tôi là 154 ; đấm vào Wolfram | Alpha và nó phun ra 10 ^{10 10 10 10 1.583328920493678} , điều mà thậm chí không cần phải tính toán. Tôi thậm chí không biết nó chứa bao nhiêu chữ số , nhưng 64 ^{4 4} chứa 463. Khá hay cho một ngôn ngữ chỉ hỗ trợ các số không rõ ràng và không có hàm số mũ; 3

Tôi có thể đã làm điều này lớn hơn nhiều, nhưng, quá mức cần thiết.

Javascript: 27 ký tự; 260.431.976 sản lượng than; Tỷ lệ 9.645.628,74

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

Mã này mã hóa đệ quy đầu vào 61Base64 61 lần. Mã hóa bất kỳ đầu vào có độ dài nào nthành Base64 sẽ tạo ra đầu ra có độ dài n * 8/6, được làm tròn thành bội số của 4.

Điều này phải được chạy từ môi trường bảng điều khiển JavaScript vốn hỗ trợ chức năng mã hóa Base64 btoa. (Bất kỳ trình duyệt hiện đại nào, nhưng không phải Node.js.) Lưu ý Chrome không thể chạy cao hơn i=61, trong khi Firefox chỉ có thể tiếp cận i=60. Cũng lưu ý rằng bảng điều khiển của Chrome thực sự không thể hiển thị đầu ra vì nó quá lớn, nhưng bạn có thể xác minh kích thước kết quả bằng cách chạy

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

Nếu chương trình này được phép chạy tối đa i=99, nó sẽ tạo ra sản lượng giả thuyết có kích thước 14,566,872,071,840 (14,5 nghìn tỷ, 14,5e12), cho tỷ lệ giả thuyết khoảng 540 tỷ (5,39e11).

Ruby, 23 ký tự - ~ ​​500000000000000 (5e14) Đầu ra

while rand
puts 0
end

Ti-Basic 84, 13 ký tự - ~ ​​3000 Đầu ra

:Disp 1
:prgmA

Đặt tên cho chương trình prgmA

hồng ngọc, 283 96 44 ký tự

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

Không phải là rất ngắn, nhưng nó bù cho nó ở đầu ra, rất nhiều mà tôi chưa thể đo lường được.

Tỷ lệ toán học 9 ký tự: ~ 4564112: 1

Sau đây là hình ảnh của đầu vào Mathicala. Tôi chưa tìm ra cách kết xuất nó trong SE.

Đây là một ảnh chụp màn hình hiển thị số chữ số trong đầu ra. IntegerDigitschuyển đổi đầu ra thành một danh sách các chữ số. Lengthđếm số chữ số.

Tổ hợp phím để nhập: 9, ctrl6, 9, ctrl6, 9, ctrl6, 9, ctrl6, 9....

Befunge-93: 48 ký tự, khoảng ((2 ^ 32) ^ 2) * đầu ra 10 ký tự

Ngăn xếp của Befunge về mặt lý thuyết là vô hạn, nhưng số lượng lưu trữ ngăn xếp bị giới hạn ở kích thước của một số nguyên dài không dấu (ở đây được giả định là 32 bit). Do đó, đối với trình thông dịch Befunge, (x + 1)> x là sai với giá trị phù hợp của x. Trước tiên, chúng tôi sử dụng thực tế này để đẩy tất cả các giá trị từ 0 đến tối đa (hai lần, với một số thứ ba), và sau đó với mỗi giá trị trên ngăn xếp, chúng tôi xuất và giảm giá trị, sau đó bật nó khi nó về 0. Cuối cùng, ngăn xếp ngăn xếp và chương trình kết thúc. Tôi có thể giảm một chút về kích thước đầu ra, nhưng nó sẽ ở đâu đó trong sân bóng đó.

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

C: 48 ký tự, khoảng. (2 ^ 32 - 1) * Đầu ra 65090 byte

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

Lưu ý rằng 65090 không chính xác và phụ thuộc vào kích thước ngăn xếp. Chương trình cuối cùng sẽ dừng lại khi nó gặp sự cố. Ngoài ra, tôi chỉ có thể đặt một chuỗi dài hơn và dài hơn trong put () để làm cho cách tiếp cận khẩu phần trở nên vô cùng, nhưng điều đó có vẻ khá gian lận.

java (131): chưa biết nhưng số lượng hữu hạn

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

Sử dụng cơ hội thấp của Math.random () để về 0 trong một vòng lặp và sau đó thực hiện 2 ^ 64-1 vòng lặp thông qua một foreach với đầu ra 1234567890;

Python 3, 115 byte, chạy trong 7983 năm (không rõ số ký tự)

EDIT: ymbirtt đánh bại tôi với nó ._.

Tôi biết, điều này không thực sự ngắn và tôi biết rằng câu trả lời Python khác dài hơn nhiều , nhưng tôi đã quyết định thực hiện điều này.

Chương trình kéo dài khoảng 8000 năm, mà như bạn biết, là một khoảng thời gian khá dài.

Những gì nó làm là liên tục có được thời gian hiện tại bằng cách sử dụng datetime.datetime.now()hàm và so sánh nó với nó 9999-12-31 24:59:59.999999, theo như tôi biết ngày tối đa trong Python.

Nếu là là ngang nhau thì chương trình dừng lại. Nếu không, nó liên tục xuất ra a.

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