这很简单。

编写尽可能短的程序，同时产生最多的输出。

为了使它有趣，产生无限输出的程序将被取消资格。

获胜者是具有最大输出大小/代码大小比率的程序。

结果基于我的计算机上的运行情况，该计算机是运行Mac OS X 10.7.5的Mac，带有Intel Core i5和8GB内存。

Python：8个字符的代码，387420489个字符的输出-比率：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个petabyes，使用的内存不超过1.7GB。

有一些事情使这个挑战比我想的要有趣。Perl似乎拒绝为任何单个列表分配超过1GB的内存。因此，对内部字符串的4字节标量引用只能重复26e7≈2 ²⁸次。$]是“旧的perl版本”数字，作为字符串，长度为8个字节，类似于5.016002。

随着更多的系统内存，它应该可以更高。假设完整的8GB实际可用，那么您应该可以使用$]x9e8内部字符串代替，内部字符串将输出1.62艾字节。

Ruby和Python，13个字符，输出599994个字符，比率为〜46153：1

999999**99999

只需将一个很大的数提高到另一个很大的数的幂即可。大约需要20秒钟才能运行。我不能增加数字，因为那会使数字变成无穷大。

（我之前做了这个，我目前正在做一个循环以获取更长的输出）

编辑：我做到了！

Ruby，28个字符，6e599999个字符输出，〜6e599998比率（我认为）

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

未经测试（出于明显的原因），但我很确定第一个数字约为1e599994，乘以599994约为6e599999。从理论上讲，它可以工作，但是我不确定它是否会使您的计算机崩溃，因此免责声明：如果它以任何方式损害您的计算机，我概不负责：P

当然，您可以继续：

Ruby，37个字符，6e359992800041字符输出，〜6e359992800040比率

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

依此类推，但我怀疑任何计算机都可以处理：P

如果允许无限输入，

cat /dev/random

既然不是

head -99 /dev/random

（25128输出：20输入= 1256.4：1）

我不在Linux机器上，但我想您可以做类似的事情

timeout 99d cat /dev/random

并获得巨大的产出。（通过GigaWatt的回复）

HQ9 +，11471

9

实际字符数因翻译而异，但是大概10000左右是正确的吗？

C＃：108个字符。比例：742123445489230793057592：1

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

它只是下载并打印Wikipedia的美国最高法院书记员清单（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次。将length的任何输入编码n为Base64会产生length 的输出n * 8/6，四舍五入为4的倍数。

这必须从本地支持Base64编码功能的JavaScript控制台环境中运行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）个字符的假设输出，假设比率约为5400亿（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个字符的比率：〜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的正确值，（x + 1）> x为假。我们利用这一事实首先将所有值从零推到最大值（两次，每三个数字一个），然后对堆栈上的每个值进行输出和递减，然后在达到零时弹出它。最终，堆栈清空，程序终止。我可能对输出大小有些怀疑，但它应该在该范围内。

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

C：约48个字符。（2 ^ 32-1）* 65090字节输出

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

请注意，65090并不精确，取决于堆栈大小。该程序最终将在崩溃时停止。另外，我可以在puts（）中放置一个越来越长的字符串，以使定量方法趋于无穷大，但这似乎很不明智。

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，然后通过一个foreach进行goin 2 ^ 64-1循环，输出为1234567890;

Python 3，115字节，运行7983年（字符数未知）

编辑：ymbirtt击败了我。

我知道，这并不是很短，而且我知道其他Python答案要长得多，但是我决定尝试一下。

该程序运行约8000年，如您所知，这是一个相当长的时间。

它所做的是使用datetime.datetime.now()函数连续获取当前时间，并将其与进行比较9999-12-31 24:59:59.999999，据我所知，这是Python中的最大日期。

如果是是平等的，程序停止。如果不是，它将连续输出a。

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