Questo è piuttosto semplice.

Scrivi il programma più corto che puoi, generando il massimo output.

Per renderlo divertente, i programmi che producono un output infinito saranno squalificati.

Il vincitore è il programma con il rapporto dimensioni / codice output più grande.

I risultati si basano su ciò che funziona sul mio computer, che è un Mac con Mac OS X 10.7.5 con un Intel Core i5 e 8 GB di memoria.

Python: codice 8 caratteri, output 387420489 caratteri - Rapporto: 48427561.125: 1

'a'*9**9

Possiamo avere il rapporto che tende all'infinito aggiungendo più **9s:

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

Per esempio:

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

che ha un rapporto di ~ 10 ^{10 10 10 10 8.568} (numero inimmaginabilmente grande).

Quindi, questi sono tutti buoni programmi che producono un sacco di output con pochissimo codice, ma nessuno di essi è davvero breve ...

brainfuck, 5 caratteri, 255 byte di output

-[.-]

Penso che questo sia l'unico caso d'uso in cui Brainfuck eccelle davvero. So che questo non vincerà, ma non credo che possiamo fare meglio dell'esempio di Python. Non solo, ma ...

brainfuck, 4 caratteri, output infinito

-[.]

Suppongo che questo sia il programma di output infinito più breve là fuori.

A dire il vero, aspetta, il mio amico ne ha appena inventato uno davvero buono.

Python, 80 byte, quantità sconosciuta di output

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

Questo programma alla fine si fermerà definitivamente, ma lo farà solo dopo circa 8000 anni. Il numero esatto di caratteri in uscita dipende dalla velocità con cui il computer può produrre caratteri.

Perl - 19 byte, output 187200000000000000 byte (9852631578947368.42: 1)

print+($]x9e7)x26e7

166 petabyes con una singola istruzione di stampa, utilizzando non più di 1,7 GB di memoria.

Ci sono alcune cose che hanno reso questa sfida più interessante che ho pensato che sarebbe stata. Perl sembra rifiutare di allocare più di 1 GB di memoria per ogni singolo elenco. Pertanto, il riferimento scalare di 4 byte alla stringa interna può essere ripetuto solo 26e7 ≈ 2 ²⁸ volte. $]è il numero della "vecchia versione perl" che, come stringa, è lungo 8 byte, simile a 5.016002.

Con più memoria di sistema, dovrebbe essere in grado di aumentare. Supponendo che gli 8 GB completi fossero effettivamente disponibili, dovresti invece essere in grado di utilizzare $]x9e8la stringa interna, che genererebbe 1,62 exabyte.

Ruby e Python, 13 caratteri, output 599994 caratteri, rapporto ~ 46153: 1

999999**99999

Aumenta semplicemente un numero molto grande alla potenza di un altro numero molto grande. Sono necessari circa 20 secondi per l'esecuzione. Non posso aumentare i numeri perché ciò renderebbe il numero infinito.

(L'ho fatto prima , attualmente sto lavorando per creare un loop per un output ancora più lungo)

Modifica: l'ho fatto!

Rubino, 28 caratteri, 6e599999 carattere in uscita, rapporto ~ 6e599998 (credo)

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

Non testato (per ovvi motivi), ma sono abbastanza sicuro che il primo numero sia circa 1e599994, che moltiplicato per 599994 è circa 6e599999. Teoricamente funzionerebbe, ma non sono sicuro se si bloccherebbe il tuo computer, quindi disclaimer: non sono responsabile se danneggia il tuo computer in alcun modo: P

Certo, puoi andare avanti:

Rubino, 37 caratteri, 6e359992800041 uscita caratteri, rapporto ~ 6e359992800040

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

E così via, ma dubito che qualsiasi computer possa gestirlo: P

Se fosse consentito l'input infinito,

cat /dev/random

Dal momento che non lo è,

head -99 /dev/random

(25128 output: 20 input = 1256,4: 1)

Non sono su una scatola Linux, ma immagino che potresti fare qualcosa del genere

timeout 99d cat /dev/random

e ottieni un risultato enorme. (tramite la risposta di GigaWatt)

HQ9 +, 11471

9

Il conteggio dei caratteri effettivi varia a seconda dell'interprete, ma probabilmente circa 10000 avrebbero ragione?

C #: 108 caratteri. Rapporto: 742123445489230793057592: 1

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

Scarica e stampa l' Elenco degli impiegati di legge della Corte Suprema degli Stati Uniti (4344904 caratteri) di wikipedia 18446744073709551615 volte.

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

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

Come funziona: in primo luogo, imposta 'su 4 ^ 3 o 64. Quindi crea ''una funzione che imposta 'su '^ 4 * volte (dove * è il suo input). '''viene quindi creata una funzione che chiama ''con l'ingresso come '^ 4. Quindi, ''''viene creata una funzione che chiama '''con '^ 4 come input. ''''viene quindi chiamato con un input di 64. Infine, ''viene modificato in una funzione che stampa uno spazio * volte; questo viene quindi chiamato con un input di '.

Alla fine 'risulta che è 64 ^{4 4 4 64} e la lunghezza del mio programma è 154 ; colpiscilo in Wolfram | Alpha e sputa 10 ^{10 10 10 10 1.583328920493678} , che non si preoccupa nemmeno di calcolare. Non so nemmeno quante cifre contenga , ma 64 ^{4 4} contiene 463. Abbastanza carino per una lingua che supporta solo numeri espliciti unari e non ha una funzione esponente; 3

Avrei potuto renderlo molto più grande, ma eccessivo.

Javascript: 27 caratteri; 260.431.976 output di caratteri; Rapporto 9.645.628,74

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

Questo codice codifica ricorsivamente l'input 61su Base64 61 volte. La codifica di qualsiasi input di lunghezza nin Base64 produce un output di lunghezza n * 8/6, arrotondato per eccesso a un multiplo di 4.

Questo deve essere eseguito da un ambiente console JavaScript che supporti nativamente la funzione di codifica Base64 btoa. (Qualsiasi browser moderno, ma non Node.js.) Nota Chrome non può essere superiore a i=61, mentre Firefox può solo raggiungere i=60. Nota anche che la console di Chrome non può effettivamente visualizzare l'output perché è troppo grande, ma puoi verificare le dimensioni del risultato eseguendo

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

Se questo programma i=99potesse funzionare al massimo , produrrebbe un ipotetico output di 14.566.872.071.840 (14.5 trilioni, 14.5e12) caratteri, per un rapporto ipotetico di circa 540 miliardi (5.39e11).

Rubino, 23 caratteri - ~ 500000000000000 (5e14) Output

while rand
puts 0
end

Ti-Basic 84, 13 caratteri - ~ 3000 Output

:Disp 1
:prgmA

Assegna un nome al programma prgmA

rubino, 283 96 44 caratteri

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

Non molto corto, ma lo compensa nell'output, che è così tanto che non sono ancora stato in grado di misurarlo.

Rapporto 9 caratteri Mathematica: ~ 4564112: 1

La seguente è una foto dell'input di Mathematica. Non ho capito come renderlo in SE.

Ecco una schermata che mostra il numero di cifre nell'output. IntegerDigitsconverte l'output in un elenco di cifre. Lengthconta il numero di cifre.

Combinazioni di tasti per entrare: 9, ctrl6, 9, ctrl6, 9, ctrl6, 9, ctrl6, 9....

Befunge-93: 48 caratteri, circa ((2 ^ 32) ^ 2) * 10 caratteri in uscita

Lo stack di Befunge è teoricamente infinito, ma i numeri che lo stack memorizza sono limitati alla dimensione di un intero lungo senza segno (qui assunto come 32 bit). Pertanto, per un interprete di Befunge, (x + 1)> x è falso per il valore corretto di x. Usiamo questo fatto per spingere prima tutti i valori da zero al massimo (due volte, con uno ogni terzo numero), quindi per ogni valore nello stack, lo produciamo e lo diminuiamo, quindi lo pop quando raggiunge lo zero. Alla fine lo stack si svuota e il programma termina. Potrei essere un po 'fuori dalla dimensione dell'output, ma dovrebbe essere da qualche parte in quel campo da baseball.

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

C: 48 caratteri, ca. (2 ^ 32 - 1) * 65090 byte di output

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

Si noti che il 65090 non è esatto e dipende dalle dimensioni dello stack. Il programma alla fine si arresterà quando si blocca. Inoltre, potrei semplicemente inserire una stringa sempre più lunga in put () per far sì che la razione si avvicini all'infinito, ma questo sembra piuttosto economico.

java (131): quantità sconosciuta ma 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 bassa probabilità di Math.random () per arrivare a 0 in un ciclo e poi passare 2 ^ 64-1 loop attraverso un foreach con l'output 1234567890;

Python 3, 115 byte, funziona per 7983 anni (numero sconosciuto di caratteri)

EDIT: ymbirtt mi ha battuto ad esso ._.

Lo so, questo non è molto breve e so che l'altra risposta di Python è molto più lunga, ma ho deciso di provare.

Il programma dura circa 8000 anni, che, come sapete, è piuttosto lungo.

Ciò che fa è ottenere costantemente l'ora corrente utilizzando la datetime.datetime.now()funzione e la confronta con 9999-12-31 24:59:59.999999, che è per quanto ne so la data massima in Python.

Se è è uguale, il programma si ferma. In caso contrario, viene continuamente emesso a.

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