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.
\n
Réponses:
Python: code 8 caractères, sortie 387420489 caractères - Ratio: 48427561.125: 1
On peut faire tendre le rapport à l'infini en ajoutant plus de
**9
s:Par exemple:
qui a un rapport de ~ 10 10 10 10 10 8,568 (nombre incroyablement élevé).
la source
**9
s, ne deviendrait-il pas finalementInfinity
?**9
s que vous pouvez mettre avant que la sortie ne devienneInfinity
.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
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.
la source
.
génère un flux infini de 0 caractères.Perl - 19 octets, sortie 187200000000000000 octets (9852631578947368.42: 1)
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 28 fois.
$]
est le numéro de «l'ancienne version de Perl» qui, sous forme de chaîne, fait 8 octets de long, ressemblant5.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.la source
Ruby et Python, 13 caractères, sortie 599994 caractères, rapport ~ 46153: 1
É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)
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
Et ainsi de suite, mais je doute que tout ordinateur puisse gérer cela: P
la source
Si une saisie infinie était autorisée,
Comme ce n'est pas le cas,
(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
et obtenez une sortie énorme. (via la réponse de GigaWatt)
la source
timeout 99d
. Oui, durée d'exécution de 99 jours. De plus, je ne suis pas certain à ce sujet, mais vous finirez par vider le pool d'entropie/dev/random
et il se bloquera, donc/dev/urandom
peut-être plus approprié. (J'ai réussi à obtenir 40 Mo / s avecurandom
et seulement 128 Ko / s avecrandom
)HQ9 +, 11471
Le nombre de caractères réel varie en fonction de l'interprète, mais environ 10000 seraient probablement exacts?
la source
C #: 108 caractères. Rapport: 742123445489230793057592: 1
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.
la source
for(ulong i=0;i<ulong.MaxValue;i++){Console.Write(new string('a',int.MaxValue));}
2147483647 caractères * 18446744073709551615 fois = 39614081238685424720914939905/81 => Ratio: 489062731341795366924875801~ - ~! - 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; 3J'aurais pu faire ça beaucoup plus grand, mais, exagéré.
la source
Javascript: 27 caractères; 260 431 976 caractères de sortie; Rapport 9.645.628,74
Ce code code récursivement
61
61 fois l'entrée en Base64. Le codage de toute entrée de longueurn
en Base64 produit une sortie de longueurn * 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 quei=61
, tandis que Firefox ne peut atteindre quei=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écutantSi 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).la source
Ruby, 23 caractères - ~ 500000000000000 (5e14) Sortie
Ti-Basic 84, 13 caractères - ~ 3000 sortie
Nommez le programme
prgmA
la source
rubis,
2839644 caractèresPas très court, mais il le compense en sortie, ce qui fait que je n'ai pas encore pu le mesurer.
la source
1e127
sortie des caractères. de toute façon, l'affectation à une variable réduirait la taille du code de moitié environ. aussi,1e99
est un plus grand nombre qui prend moins de place. utilisez égalementmap
au lieu deeach
, utilisez à laputs
place deprint
, supprimez les espaces supplémentaires entreprint
et"ier...
. Vous pouvez également remplacer cette grosse chaîne par'a'*999
(ou même?a*999
) qui est une chaîne plus longue qui prend moins de place. résumé: ce n'est pas du tout joué au golf(0..1e99).map
à une variable? commea=(0...1e99).map;a{a{a{a{a{puts'a'*99}}}}}
a=(0...1e99).map
. Vous voudrez peut-être revenir un peu sur ce point.0..1e9
utiliserait environ 4 Go.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.
IntegerDigits
convertit la sortie en une liste de chiffres.Length
compte le nombre de chiffres.D'entrer dans des séquences de touches: 9, ctrl6, 9, ctrl6, 9, ctrl6, 9, ctrl6, 9....
la source
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.
la source
C: 48 caractères, env. (2 ^ 32 - 1) * 65090 octets de sortie
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.
la source
java (131): montant inconnu mais fini
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;
la source
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
.la source