Este es bastante simple.

Escriba el programa más corto que pueda, mientras genera la mayor salida.

Para que sea divertido, los programas que producen una salida infinita serán descalificados.

El ganador es el programa con la mayor proporción de tamaño de salida / tamaño de código.

Los resultados se basan en lo que funciona en mi computadora, que es una Mac con Mac OS X 10.7.5 con un Intel Core i5 y 8 GB de memoria.

Python: código de 8 caracteres, salida de 387420489 caracteres - Relación: 48427561.125: 1

'a'*9**9

Podemos hacer que la relación tienda al infinito agregando más **9s:

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

Por ejemplo:

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

que tiene una relación de ~ 10 ^{10 10 10 10 8.568} (número inimaginablemente grande).

Entonces, todos estos son buenos programas que producen muchos resultados con muy poco código, pero ninguno de ellos es realmente corto ...

brainfuck, 5 caracteres, 255 bytes de salida

-[.-]

Creo que este es el único caso de uso en el que Brainfuck realmente sobresale. Sé que este no va a ganar, pero no creo que podamos hacerlo mejor que el ejemplo de Python. No solamente eso, pero...

brainfuck, 4 caracteres, salida infinita

-[.]

Supongo que este es el programa de salida infinita más corto que existe.

En realidad, espera, mi compañero acaba de encontrar uno realmente bueno.

Python, 80 bytes, cantidad desconocida de salida

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

Este programa definitivamente se detendrá eventualmente, pero solo lo hará después de aproximadamente 8,000 años. El número exacto de caracteres de salida depende de la velocidad a la que su computadora puede producir caracteres.

Perl: salida de 19 bytes, 187200000000000000 bytes (9852631578947368.42: 1)

print+($]x9e7)x26e7

166 petabyes con una sola declaración de impresión, utilizando no más de 1.7GB de memoria.

Hay algunas cosas que hicieron que este desafío fuera más interesante de lo que pensé que sería. Perl parece negarse a asignar más de 1 GB de memoria a una sola lista. Por lo tanto, la referencia escalar de 4 bytes a la cadena interna solo puede repetirse 26e7 ≈ 2 ²⁸ veces. $]es el número 'Perl versión antigua', que, como una cadena, es de 8 bytes de longitud, que se asemeja 5.016002.

Con más memoria del sistema, debería poder ir más alto. Suponiendo que los 8GB completos estuvieran realmente disponibles, debería poder usarlos $]x9e8para la cadena interna, lo que generaría 1,62 exabytes.

Ruby y Python, 13 caracteres, salida de caracteres 599994, relación ~ 46153: 1

999999**99999

Simplemente eleva un número muy grande a la potencia de otro número muy grande. Tarda unos 20 segundos en correr. No puedo aumentar los números porque eso haría que el número se convirtiera en Infinito.

(Hice esto antes , actualmente estoy trabajando en hacer un bucle para una salida aún más larga)

Editar: lo hice!

Ruby, 28 caracteres, salida de caracteres 6e599999, relación ~ 6e599998 (creo)

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

No probado (por razones obvias), pero estoy bastante seguro de que el primer número es aproximadamente 1e599994, que multiplicado por 599994 es aproximadamente 6e599999. Teóricamente funcionaría, pero no estoy seguro de si bloquearía su computadora, por lo tanto, descargo de responsabilidad: no soy responsable si daña su computadora de alguna manera: P

Por supuesto, puedes continuar:

Rubí, 37 caracteres, salida de caracteres 6e359992800041, relación ~ 6e359992800040

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

Y así sucesivamente, pero dudo que cualquier computadora pueda manejar eso: P

Si se permitía una entrada infinita,

cat /dev/random

Como no lo es,

head -99 /dev/random

(Salida 25128: 20 entradas = 1256.4: 1)

No estoy en una caja de Linux, pero imagino que podrías hacer algo como

timeout 99d cat /dev/random

y obtener una gran salida. (a través de la respuesta de GigaWatt)

HQ9 +, 11471

9

El recuento de caracteres real varía según el intérprete, pero probablemente alrededor de 10000 sería correcto.

C #: 108 caracteres. Relación: 742123445489230793057592: 1

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

Simplemente descarga e imprime la Lista de empleados de la wikipedia de la Corte Suprema de los Estados Unidos (4344904 caracteres) 18446744073709551615 veces.

~ - ~! - Ratio: (64 ^{4 4 4 64} ) / 154 ~ = 10 ^{10 10 10 10 1.583328920493678}

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

Cómo funciona: Primero, se establece 'en 4 ^ 3, o 64. Luego, realiza ''una función que se establece 'en '^ 4 * veces (donde * es su entrada). '''Luego se realiza una función que llama ''con la entrada como '^ 4. Luego, ''''se realiza una función que llama '''con '^ 4 como entrada. ''''luego se llama con una entrada de 64. Finalmente, ''se cambia a una función que imprime un espacio * veces; Esto se llama con una entrada de '.

Resulta que, al final, 'es 64 ^{4 4 4 64} , y la duración de mi programa es 154 ; pon eso en Wolfram | Alpha y escupe 10 ^{10 10 10 10 1.583328920493678} , que ni siquiera se molesta en calcular. Ni siquiera sé cuántos dígitos contiene , pero 64 ^{4 4} contiene 463. Bastante bueno para un lenguaje que solo admite números explícitos unarios y no tiene una función de exponente; 3

Podría haber hecho esto mucho más grande, pero exagerado.

Javascript: 27 caracteres; 260,431,976 salida de caracteres; 9.645.628,74 ratio

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

Este código codifica recursivamente la entrada 61a Base64 61 veces. Codificar cualquier entrada de longitud na Base64 produce una salida de longitud n * 8/6, redondeada a un múltiplo de 4.

Esto debe ejecutarse desde un entorno de consola de JavaScript que admita de forma nativa la función de codificación Base64 btoa. (Cualquier navegador moderno, pero no Node.js.) Nota Chrome no puede ejecutarse más alto que i=61, mientras que Firefox solo puede alcanzar i=60. Tenga en cuenta también que la consola de Chrome no puede mostrar el resultado porque es demasiado grande, pero puede verificar el tamaño del resultado ejecutando

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

Si se permitiera que este programa funcionara al máximo i=99, produciría una producción hipotética de 14,566,872,071,840 (14.5 billones, 14.5e12) de caracteres, para una relación hipotética de alrededor de 540 mil millones (5.39e11).

Ruby, 23 caracteres - ~ 500000000000000 (5e14) Salida

while rand
puts 0
end

Ti-Basic 84, 13 caracteres - ~ 3000 de salida

:Disp 1
:prgmA

Nombra el programa prgmA

rubí, 283 96 44 caracteres

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

No es muy corto, pero lo compensa en la salida, que es tanto que aún no he podido medirlo.

Mathematica 9 chars Ratio: ~ 4564112: 1

La siguiente es una imagen de la entrada de Mathematica. No he descubierto cómo representarlo en SE.

Aquí hay una captura de pantalla que muestra el número de dígitos en la salida. IntegerDigitsconvierte la salida a una lista de dígitos. Lengthcuenta el número de dígitos.

Teclas para escribir: 9, ctrl6, 9, ctrl6, 9, ctrl6, 9, ctrl6, 9....

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

La pila de Befunge es teóricamente infinita, pero los números que se almacenan en la pila están limitados al tamaño de un entero largo sin signo (aquí se supone que son 32 bits). Por lo tanto, para un intérprete de Befunge, (x + 1)> x es falso para el valor adecuado de x. Utilizamos este hecho para primero empujar todos los valores de cero al máximo (dos veces, con un número cada tres), y luego para cada valor en la pila, lo sacamos y lo decrementamos, luego lo sacamos cuando llega a cero. Finalmente, la pila se vacía y el programa termina. Puedo estar un poco fuera del tamaño de salida, pero debería estar en algún lugar de ese estadio.

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

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

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

Tenga en cuenta que el 65090 no es exacto y depende del tamaño de la pila. El programa finalmente se detendrá cuando se bloquee. Además, podría simplemente poner una cadena cada vez más larga en gets () para hacer que la ración se acerque al infinito, pero eso parece bastante engañoso.

Java (131): cantidad desconocida pero 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 la baja probabilidad de Math.random () para llegar a 0 en un bucle y luego ir 2 ^ 64-1 bucles a través de un foreach con la salida 1234567890;

Python 3, 115 bytes, se ejecuta durante 7983 años (número desconocido de caracteres)

EDITAR: ymbirtt me ganó ._.

Lo sé, esto no es realmente corto, y sé que la otra respuesta de Python es mucho más larga, pero decidí darle una oportunidad.

El programa tiene una duración de aproximadamente 8000 años, lo cual, como saben, es bastante tiempo.

Lo que hace es obtener continuamente la hora actual usando la datetime.datetime.now()función, y la compara 9999-12-31 24:59:59.999999, que es hasta donde yo sé la fecha máxima en Python.

Si es que es igual, el programa se detiene. Si no es así, sale continuamente a.

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