Celui-ci est assez simple.

Écrivez le programme le plus court possible, tout en générant le plus de sortie.

Pour le rendre amusant, les programmes qui produisent une sortie infinie seront disqualifiés.

Le gagnant est le programme avec le plus grand rapport taille de sortie / taille de code.

Les résultats sont basés sur ce qui fonctionne sur mon ordinateur, qui est un Mac fonctionnant sous Mac OS X 10.7.5 avec un Intel Core i5 et 8 Go de mémoire.

Python: code 8 caractères, sortie 387420489 caractères - Ratio: 48427561.125: 1

'a'*9**9

On peut faire tendre le rapport à l'infini en ajoutant plus de **9s:

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

Par exemple:

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

qui a un rapport de ~ 10 ^{10 10 10 10 8,568} (nombre incroyablement élevé).

Donc, ce sont tous de bons programmes qui produisent beaucoup de sortie avec très peu de code, mais aucun d'eux n'est vraiment court ...

brainfuck, 5 caractères, 255 octets de sortie

-[.-]

Je pense que c'est le seul cas d'utilisation où le brainfuck excelle vraiment. Je sais que celui-ci ne va pas gagner, mais je ne pense pas que nous puissions faire mieux que l'exemple Python. Non seulement cela, mais ...

brainfuck, 4 caractères, sortie infinie

-[.]

Je suppose que c'est le programme à sortie infinie le plus court du marché.

En fait, attendez, mon compagnon vient d'en trouver un très bon.

Python, 80 octets, quantité de sortie inconnue

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

Ce programme s'arrêtera définitivement, mais ne le fera qu'après environ 8 000 ans. Le nombre exact de caractères émis dépend de la vitesse à laquelle votre ordinateur peut produire des caractères.

Perl - 19 octets, sortie 187200000000000000 octets (9852631578947368.42: 1)

print+($]x9e7)x26e7

166 pétaoctets avec une seule déclaration d'impression, n'utilisant pas plus de 1,7 Go de mémoire.

Il y a quelques choses qui ont rendu ce défi plus intéressant que je le pensais. Perl semble refuser d'allouer plus de 1 Go de mémoire à une seule liste. Par conséquent, la référence scalaire de 4 octets à la chaîne interne ne peut être répétée que 26e7 × 2 ²⁸ fois. $]est le numéro de «l'ancienne version de Perl» qui, sous forme de chaîne, fait 8 octets de long, ressemblant 5.016002.

Avec plus de mémoire système, il devrait pouvoir aller plus haut. En supposant que les 8 Go complets étaient réellement disponibles, vous devriez pouvoir utiliser $]x9e8à la place la chaîne interne, qui produirait 1,62 exaoctets.

Ruby et Python, 13 caractères, sortie 599994 caractères, rapport ~ 46153: 1

999999**99999

Élève simplement un très grand nombre à la puissance d'un autre très grand nombre. Prend environ 20 secondes pour fonctionner. Je ne peux pas augmenter les nombres, car cela ferait du nombre Infinity.

(Je l'ai fait plus tôt , je travaille actuellement sur la création d'une boucle pour une sortie encore plus longue)

Edit: je l'ai fait!

Ruby, 28 caractères, sortie 6e599999 caractères, rapport ~ 6e599998 (je pense)

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

Non testé (pour des raisons évidentes), mais je suis à peu près sûr que le premier nombre est d'environ 1e599994, qui multiplié par 599994 est d'environ 6e599999. Théoriquement, cela fonctionnerait, mais je ne suis pas sûr que cela planterait votre ordinateur, donc avis de non-responsabilité: je ne suis pas responsable s'il endommage votre ordinateur de quelque manière que ce soit: P

Bien sûr, vous pouvez continuer:

Ruby, 37 caractères, sortie 6e359992800041 caractères, rapport ~ 6e359992800040

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

Et ainsi de suite, mais je doute que tout ordinateur puisse gérer cela: P

Si une saisie infinie était autorisée,

cat /dev/random

Comme ce n'est pas le cas,

head -99 /dev/random

(Sortie 25128: 20 entrées = 1256,4: 1)

Je ne suis pas sur une boîte Linux, mais j'imagine que vous pourriez faire quelque chose comme

timeout 99d cat /dev/random

et obtenez une sortie énorme. (via la réponse de GigaWatt)

HQ9 +, 11471

9

Le nombre de caractères réel varie en fonction de l'interprète, mais environ 10000 seraient probablement exacts?

C #: 108 caractères. Rapport: 742123445489230793057592: 1

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

Il télécharge et imprime simplement la liste des clercs de Wikipédia de la Cour suprême des États-Unis (4344904 caractères) 18446744073709551615 fois.

~ - ~! - Rapport: (64 ^{4 4 4 64} ) / 154 ~ = 10 ^{10 10 10 10 1,583328920493678}

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

Comment ça marche: Tout d'abord, il définit '4 ^ 3, ou 64. Ensuite, il crée ''une fonction qui définit 'à '^ 4 * fois (où * est son entrée). '''devient alors une fonction qui appelle ''avec l'entrée comme '^ 4. Ensuite, ''''on fait une fonction qui appelle '''avec '^ 4 comme entrée. ''''est ensuite appelé avec une entrée de 64. Enfin, ''est changé en une fonction qui imprime un espace * fois; ceci est alors appelé avec une entrée de '.

Il s'avère, en fin de compte, 'est 64 ^{4 4 4 64} , et la durée de mon programme est 154 ; poinçonner cela dans Wolfram | Alpha et il crache 10 ^{10 10 10 10 1.583328920493678} , qu'il n'a même pas la peine de calculer. Je ne sais même pas combien de chiffres il contient , mais 64 ^{4 4} contient 463. Assez bien pour une langue qui ne prend en charge que les nombres explicites unaires et n'a pas de fonction exposant; 3

J'aurais pu faire ça beaucoup plus grand, mais, exagéré.

Javascript: 27 caractères; 260 431 976 caractères de sortie; Rapport 9.645.628,74

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

Ce code code récursivement 6161 fois l'entrée en Base64. Le codage de toute entrée de longueur nen Base64 produit une sortie de longueur n * 8/6, arrondie à un multiple de 4.

Cela doit être exécuté à partir d'un environnement de console JavaScript qui prend en charge nativement la fonction de codage Base64 btoa. (Tout navigateur moderne, mais pas Node.js.) Remarque Chrome ne peut pas fonctionner plus haut que i=61, tandis que Firefox ne peut atteindre que i=60. Notez également que la console de Chrome ne peut pas réellement afficher la sortie car elle est trop grande, mais vous pouvez vérifier la taille du résultat en exécutant

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

Si ce programme était autorisé à fonctionner au maximum i=99, il produirait une production hypothétique de taille 14 566 872 071 840 (14 500 milliards, 14,5 e12) caractères, pour un ratio hypothétique d'environ 540 milliards (5,39 e11).

Ruby, 23 caractères - ~ 500000000000000 (5e14) Sortie

while rand
puts 0
end

Ti-Basic 84, 13 caractères - ~ 3000 sortie

:Disp 1
:prgmA

Nommez le programme prgmA

rubis, 283 96 44 caractères

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

Pas très court, mais il le compense en sortie, ce qui fait que je n'ai pas encore pu le mesurer.

Mathematica 9 caractères Ratio: ~ 4564112: 1

Voici une image de l'entrée Mathematica. Je n'ai pas compris comment le rendre en SE.

Voici une capture d'écran montrant le nombre de chiffres dans la sortie. IntegerDigitsconvertit la sortie en une liste de chiffres. Lengthcompte le nombre de chiffres.

D'entrer dans des séquences de touches: 9, ctrl6, 9, ctrl6, 9, ctrl6, 9, ctrl6, 9....

Befunge-93: 48 caractères, environ ((2 ^ 32) ^ 2) * sortie de 10 caractères

La pile de Befunge est théoriquement infinie, mais les nombres que la pile stocke sont limités à la taille d'un entier long non signé (ici supposé être 32 bits). Ainsi, pour un interprète Befunge, (x + 1)> x est faux pour la valeur correcte de x. Nous utilisons ce fait pour pousser d'abord toutes les valeurs de zéro au maximum (deux fois, avec un chiffre tous les trois), puis pour chaque valeur de la pile, nous la sortons et la décrémentons, puis la sautons lorsqu'elle atteint zéro. Finalement, la pile se vide et le programme se termine. Je suis peut-être un peu à l'écart de la taille de sortie, mais cela devrait être quelque part dans ce stade.

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

C: 48 caractères, env. (2 ^ 32 - 1) * 65090 octets de sortie

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

Notez que le 65090 n'est pas exact et dépend de la taille de la pile. Le programme s'arrêtera finalement lorsqu'il se bloque. De plus, je pourrais simplement mettre une chaîne de plus en plus longue dans put () pour faire approcher la ration à l'infini, mais cela semble plutôt tricheur.

java (131): montant inconnu mais fini

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

Utiliser la faible chance de Math.random () pour arriver à 0 dans une boucle, puis passer à 2 ^ 64-1 boucles à travers un foreach avec la sortie 1234567890;

Python 3, 115 octets, fonctionne pendant 7983 ans (nombre de caractères inconnu)

EDIT: ymbirtt m'a battu ._.

Je sais, ce n'est pas vraiment court, et je sais que l'autre réponse Python est beaucoup plus longue, mais j'ai décidé de tenter le coup.

Le programme dure environ 8 000 ans, ce qui, comme vous le savez, est assez long.

Il obtient en permanence l'heure actuelle à l'aide de la datetime.datetime.now()fonction et la compare à9999-12-31 24:59:59.999999 , ce qui est autant que je sache la date maximale en Python.

Si est est égal, le programme arrête. Si ce n'est pas le cas, il sort continuellement a.

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