Este é bastante simples.

Escreva o programa mais curto possível, enquanto gera o máximo de resultados.

Para torná-lo divertido, os programas que produzem uma saída infinita serão desqualificados.

O vencedor é o programa com a maior proporção de tamanho de saída / tamanho de código.

Os resultados são baseados no que funciona no meu computador, que é um Mac executando o Mac OS X 10.7.5 com um Intel Core i5 e 8 GB de memória.

Python: código de 8 caracteres, saída de 387420489 caracteres - Proporção: 48427561.125: 1

'a'*9**9

Podemos ter a razão tendendo ao infinito adicionando mais **9s:

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

Por exemplo:

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

que tem uma proporção de ~ 10 ^{10 10 10 10 8.568} (número inimaginavelmente grande).

Portanto, todos esses são bons programas que produzem muita saída com muito pouco código, mas nenhum deles é realmente curto ...

brainfuck, 5 caracteres, 255 bytes de saída

-[.-]

Eu acho que esse é o único caso de uso em que o cérebro realmente se destaca. Eu sei que este não vai ganhar, mas acho que não podemos fazer melhor do que o exemplo do Python. Não só isso, mas ...

brainfuck, 4 caracteres, saída infinita

-[.]

Suponho que esse seja o programa de saída infinita mais curto do mercado.

Na verdade, espere, meu companheiro acabou de encontrar uma boa.

Python, 80 bytes, quantidade desconhecida de saída

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

Esse programa definitivamente será interrompido eventualmente, mas somente após aproximadamente 8.000 anos. O número exato de caracteres de saída depende da taxa na qual o computador pode produzir caracteres.

Perl - 19 bytes, saída de 187200000000000000 bytes (9852631578947368.42: 1)

print+($]x9e7)x26e7

166 petabyes com uma única declaração de impressão, usando não mais que 1,7 GB de memória.

Há algumas coisas que tornaram esse desafio mais interessante do que pensei que seria. O Perl parece se recusar a alocar mais de 1 GB de memória para qualquer lista única. Portanto, a referência escalar de 4 bytes para a cadeia interna pode ser repetida apenas 26e7 ± 2 ²⁸ vezes. $]é o número da 'versão perl antiga' que, como uma string, tem 8 bytes de comprimento, semelhante a 5.016002.

Com mais memória do sistema, deve poder subir mais. Supondo que os 8 GB completos estejam realmente disponíveis, você poderá usar $]x9e8a cadeia interna, que produziria 1,62 exabytes.

Ruby e Python, 13 caracteres, saída de caracteres 599994, proporção ~ 46153: 1

999999**99999

Simplesmente eleva um número muito grande ao poder de outro número muito grande. Demora cerca de 20 segundos para executar. Não posso aumentar os números, porque isso tornaria o número infinito.

(Eu fiz isso anteriormente , atualmente estou trabalhando em criar um loop para uma saída ainda mais longa)

Edit: Eu fiz isso!

Ruby, 28 caracteres, saída 6e599999, ~ 6e599998 (acho)

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

Não testado (por razões óbvias), mas tenho certeza de que o primeiro número é cerca de 1e599994, multiplicado por 599994 é cerca de 6e599999. Teoricamente, isso funcionaria, mas não tenho certeza se isso causaria um travamento no seu computador; portanto, exoneração de responsabilidade: não sou responsável se ele danificar seu computador de qualquer forma: P

Claro, você pode continuar:

Ruby, 37 caracteres, saída 6e359992800041 char, ~ proporção 6e359992800040

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

E assim por diante, mas duvido que qualquer computador possa lidar com isso: P

Se uma entrada infinita fosse permitida,

cat /dev/random

Desde que não é,

head -99 /dev/random

(Saída 25128: 20 entrada = 1256,4: 1)

Não estou no Linux, mas imagino que você poderia fazer algo como

timeout 99d cat /dev/random

e obtenha uma enorme produção. (via resposta de GigaWatt)

HQ9 +, 11471

9

A contagem real de caracteres varia de acordo com o intérprete, mas provavelmente cerca de 10000 estaria certo?

C #: 108 caracteres. Proporção: 742123445489230793057592: 1

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

Ele apenas baixa e imprime a lista de funcionários da wikipedia na Suprema Corte dos Estados Unidos (4344904 caracteres) 18446744073709551615 vezes.

~ - ~! - Relação: (64 ^{4 4 4 64} ) / 154 ~ = 10 ^{10 10 10 10 1.583328920493678}

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

Como funciona: Primeiro, define 'para 4 ^ 3 ou 64. Em seguida, ''cria uma função que define 'para '^ 4 * vezes (onde * é a entrada). '''é então criada uma função que chama ''com a entrada como '^ 4. Em seguida, ''''é feita uma função que chama '''com '^ 4 como de entrada. ''''é então chamado com uma entrada de 64. Finalmente, ''é alterado para uma função que imprime um espaço * vezes; isso é chamado com uma entrada de '.

Acontece que, no final, 'é 64 ^{4 4 4 64} e a duração do meu programa é 154 ; insira isso no Wolfram | Alpha e ele cospe 10 ^{10 10 10 10 1.583328920493678} , que nem se importa em calcular. Eu nem sei quantos dígitos ele contém , mas 64 ^{4 4} contém 463. Muito bom para uma linguagem que suporta apenas números explícitos unários e não possui uma função de expoente;

Eu poderia ter feito isso muito maior, mas exagero.

Javascript: 27 caracteres; Saída de 260.431.976 char; Relação 9.645.628,74

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

Esse código codifica recursivamente a entrada 61para Base64 61 vezes. Codificar qualquer entrada de comprimento npara Base64 produz uma saída de comprimento n * 8/6, arredondada para um múltiplo de 4.

Isso deve ser executado em um ambiente de console JavaScript que suporte nativamente a função de codificação Base64 btoa. (Qualquer navegador moderno, mas não o Node.js.) Nota O Chrome não pode ser superior a i=61, enquanto o Firefox só pode alcançá-lo i=60. Observe também que o console do Chrome não pode realmente exibir a saída porque é muito grande, mas você pode verificar o tamanho do resultado executando

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

Se fosse permitido que esse programa funcionasse ao máximo i=99, produziria uma produção hipotética de 14.566.872.071.840 caracteres (14,5 trilhões, 14,5e12) caracteres, para uma proporção hipotética de cerca de 540 bilhões (5,39e11).

Ruby, 23 caracteres - ~ 500000000000000 (5e14) Saída

while rand
puts 0
end

Ti-Basic 84, 13 caracteres - ~ 3000 saídas

:Disp 1
:prgmA

Nomeie o programa prgmA

rubi, 283 96 44 caracteres

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

Não é muito curto, mas compensa na saída, o que é tanto que ainda não consegui medi-lo.

Proporção de 9 caracteres do Mathematica: ~ 4564112: 1

A seguir, é apresentada uma imagem da entrada do Mathematica. Eu não descobri como renderizá-lo no SE.

Aqui está uma captura de tela mostrando o número de dígitos na saída. IntegerDigitsconverte a saída em uma lista de dígitos. Lengthconta o número de dígitos.

Teclar para entrar: 9, ctrl6, 9, ctrl6, 9, ctrl6, 9, ctrl6, 9....

Befunge-93: 48 caracteres, aproximadamente ((2 ^ 32) ^ 2) * saída de 10 caracteres

A pilha de Befunge é teoricamente infinita, mas os números que armazenam as pilhas são limitados ao tamanho de um inteiro longo sem sinal (aqui assumido como sendo de 32 bits). Assim, para um intérprete Befunge, (x + 1)> x é falso para o valor apropriado de x. Usamos esse fato para empurrar primeiro todos os valores de zero para o máximo (duas vezes, com um a cada terceiro número) e, em seguida, para cada valor na pilha, nós o produzimos e o diminuímos, depois o pop quando chegamos a zero. Eventualmente, a pilha esvazia e o programa termina. Talvez eu esteja um pouco desconectado do tamanho da saída, mas deve estar em algum lugar nesse estádio.

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

C: 48 caracteres, aprox. (2 ^ 32 - 1) * saída de 65090 bytes

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

Observe que o 65090 não é exato e depende do tamanho da pilha. O programa acabará parando quando ele falhar. Além disso, eu poderia colocar uma string cada vez mais longa em puts () para fazer a ração se aproximar do infinito, mas isso parece bastante barato.

java (131): quantidade desconhecida, mas finita

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

Usando a baixa chance de Math.random () para chegar a 0 em um loop e, em seguida, passando 2 ^ 64-1 loops através de um foreach com a saída 1234567890;

Python 3, 115 bytes, é executado por 7983 anos (número desconhecido de caracteres)

EDIT: ymbirtt me venceu ._.

Eu sei, isso não é muito curto e sei que a outra resposta do Python é muito mais longa, mas decidi tentar.

O programa dura cerca de 8000 anos, o que, como você sabe, é bastante demorado.

O que ele faz é obter continuamente o tempo atual usando a datetime.datetime.now()função e compará-lo a 9999-12-31 24:59:59.999999, que é até onde eu sei a data máxima no Python.

Se é é igual, o programa pára. Caso contrário, ele gera continuamente a.

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