Dans le webcomic Darths & Droids , Pete, qui joue R2-D2 dans la campagne de jeu de rôle fictive autour de laquelle la bande dessinée est basée, affirme une fois (avertissement: spoilers potentiels dans la bande dessinée liée) que, avec l'Orbe perdu de Phanastacoria monté sur son sonde de choc, il peut maintenant préparer un énorme 1048576d4des dommages. (Le MJ n'a ni confirmé ni nié cela.) Puisqu'il devrait être raisonnablement évident que presque personne n'aura réellement la patience de lancer autant de dés, écrivez un programme informatique pour le faire pour lui, produisant la valeur totale roulée de manière raisonnable. format. Les candidatures seront classées par taille de programme (programme le plus court, par nombre d'octets, victoires), à la fois dans l'ensemble et par langue, avec des temps de rupture des liens. La réponse peut être soit un programme complet, soit une définition de fonction.
Scores par langue
Pyth
Maltysen - 8 octets *
Jakube - 10 octets
APL
Alex A - 10 octets
CJam
Optimiseur - 11 octets
J
ɐɔıʇǝɥʇuʎs - 12 octets **
Clip10
Ypnypn - 12 octets **
K
JohnE - 13 octets
Ti-84 BASIC
SuperJedi224 - 17 octets *
R
MickyT - 23 octets
OCTAVE / MATLAB
Oebele - 24 octets
PARI / GP
Charles - 25 octets **
Wolfram / Mathematica
LegionMammal978 - 27 octets
Perl
Nutki - 29 octets
AsciiThenAnsii - 34 octets
Rubis
Haegin - 32 octets **
ConfusedMr_C - 51 octets **
Commodore Basic
Marque - 37 octets **
PHP
Ismael Miguel - 38 octets
VBA
Sean Cheshire - 40 octets **
PowerShell
Nacht - 41 octets **
Javascript
Ralph Marshall - 41 octets
edc65 - 54 octets (Nécessite la fonctionnalité ES6 non disponible dans tous les navigateurs.)
Lua
cryptych - 51 octets
Java
RobAu - 52 octets **
Géobits - 65 octets
C
Functino - 57 octets
Python
CarpetPython - 58 octets
Postgre / SQL
Andrew - 59 octets **
Rapide
Skrundz - 69 octets
GoatInTheMachine - 81 octets
Haskell
Zeta - 73 octets **
ActionScript
Brian - 75 octets **
> <>
ConfusedMr_C - 76 octets
ALLER
Kristoffer Sall-Storgaard - 78 octets
C #
Brandon - 91 octets **
Andrew - 105 octets
Ewan - 148 octets
Rayure
SuperJedi224 - 102 octets
C ++
Michelfrancis Bustillos - 154 octets
Polyglottes
Ismael Miguel (Javascript / ActionScript2) - 67 octets
Top 10 dans l'ensemble
Maltysen Alex A Jakube Optimiseur ɐɔıʇǝɥʇuʎs / Ypnypn (ordre incertain) JohnE SuperJedi224 MickyT Oebele
Avertissement - les entrées marquées d'un * sont TRÈS LENTES.
Programmé marqué ** Je n'ai pas encore pu tester correctement
1048576d4
peut ne pas être claire pour certains utilisateurs. Il serait utile de fournir une description précise de ce qui doit être calculé et des directives à suivre.Réponses:
Pyth -
98 octetsUtilise une méthode simple évidente de sommation de randint. Ça m'a pris minute à réaliser
1048576
était2^20
, maintenant je me sens vraiment stupide. Merci à @Jakube de m'avoir sauvé un octet en le signalant2^20 = 4^10
.Le temps d'exécution est horrible, il n'a pas encore fini sur mon ordinateur, il n'y a donc aucun intérêt à le faire fonctionner en ligne alors voici celui-
2^10
ci: Essayez-le en ligne ici .la source
2^20 = 4^10
1024d4
.Perl -
4844373934 octetsImprime la somme sans retour à la ligne.
4 octets enregistrés en remplaçant
2**20
(merci Maltysen) et en supprimant les guillemets autour de l'impression.Enregistré 7 octets supplémentaires en réorganisant le code (merci Thaylon!)
Perdu 2 octets parce que mon ancien code générait 0-4 (il devrait être 1-4).
Encore une fois, économisé 5 octets grâce à Caek et nutki.
Code non golfé et correctement écrit:
la source
int(rand(5))
renvoie la plage de 0 à 4 tandis que d4 devrait être de 1 à 4.$s+=int rand(4)+1for(1..2**20);print$s
La suppression de la parenthèse pour int fonctionne également pour moi, pour enregistrer un trait.APL,
1110 octetsCela prend simplement la somme d'un tableau de 2 20 = 1048576 entiers aléatoires compris entre 1 et 4.
Vous pouvez comparer cela sur TryAPL en imprimant l'horodatage avant et après. Cela prend environ 0,02 seconde.
Un octet sauvé grâce à marinus et FUZxxl!
la source
+/?4⍴⍨2*20
+/?4⍴⍨2*20
plutôt.Ti-84 Basic, 17 octets
Empreinte totale - Taille de l'en-tête du programme = 17 octets
Durée d' exécution : inconnue, estimée à 5-6 heures en fonction des performances pour un plus petit nombre de rouleaux (donc, en gros, pas très bon)
la source
R,
32242321 octetsEdit: Débarrassé de la
as.integer
division entière utilisée%/%
. Accélérez-le légèrement.Merci à Alex A pour l'exemple d'échantillon ... et Giuseppe pour avoir retiré le
r=
Testé avec
Les sorties
Pour une vitesse pure, ce qui suit se termine en microsecondes. Cependant, je ne suis pas sûr d'avoir ma logique correcte. Les résultats semblent cohérents avec la méthode aléatoire. Dommage que ce soit une longueur plus longue.
Voici un chronométrage que j'ai fait sur ma machine
la source
sample()
à la place derunif()
, à savoirsum(sample(4,2^20,r=T))
.sample()
c'est aussi plus rapide!r=T
,T
c'est bien pour le remplacementPython 2, 58 octets
Nous obtenons 1048576 caractères aléatoires du système d'exploitation, prenons 2 bits de chacun et les additionnons. L'utilisation de la
os
bibliothèque semble économiser quelques caractères par rapport à l'utilisation de larandom
bibliothèque.Cela prend environ 0,2 seconde sur mon PC.
la source
CJam,
1211 octetsC'est assez simple:
Mais la beauté de cela est que c'est vraiment très rapide aussi! Sur ma machine (et en utilisant le compilateur Java ) cela prend en moyenne 70 millisecondes.
La version en ligne prend environ 1,7 seconde sur ma machine.
Mise à jour : 1 octet enregistré grâce à DocMax
la source
YK#_{4mr+}*
4A#
au lieu deYK#
), mais vous m'avez battu. :)JavaScript (ES6), 54 octets
Temps moyen <100 msec. Exécutez l'extrait de code pour tester (dans Firefox)
Explication
Sans package statistique intégré, en Javascript, le moyen le plus court pour obtenir la somme d'un million de nombres aléatoires est d'appeler random () un million de fois. Donc tout simplement
Maintenant, ajouter 1 pour un million de fois est exactement la même chose que d'ajouter 1 million, ou mieux encore, commencez la somme avec 1 million, puis ajoutez le reste:
Puis golf, supprimez la variable temp r et supprimez la déclaration des variables locales.
t
est un paramètre, car il est nécessaire de raccourcir la déclaration def
.i
est global (mauvaise chose)Trouvez ensuite un moyen d'éviter le «retour» en utilisant une fonction interne sans nom. Comme effet secondaire, nous gagnons un autre paramètre donc pas de globaux utilisés
la source
Perl, 29
Génère un tableau de la longueur requise.
la source
~~
n'est pas un smartmatch, juste une inversion double bit pour forcer le contexte scalaire. Un chemin d'un caractère plus long seraitprint$x=map...
. Peut-être que sur les versions plus récentes, il avertit en raison d'une ambiguïté avec smartmatch, mais il semble fonctionner sans avertissements sur mon système et ici: ideone.com/LAIWzqJ (12 octets, environ 9,8 millisecondes)
Je soupçonne que cela est principalement limité par la bande passante mémoire: je ne peux même pas l'obtenir pour maximiser un seul cœur ...
Vous pouvez tester cela avec le code suivant:
Cela l'exécute en 4 groupes de 20 pistes et renvoie le nombre de millisecondes du temps moyen dans le groupe le plus rapide. Un interprète peut être trouvé ici .
la source
Pyth, 10 octets
Cela a un peu plus d'octets que la solution Pyth de @ Maltysen. Mais il fonctionne en 8,5 secondes sur mon ordinateur portable, tandis que la solution de @ Maltysen n'a produit aucune solution en 20 minutes de fonctionnement.
Mais encore un peu trop lent pour le compilateur en ligne.
Explication
la source
Java, 65
Puisque nous avons des partitions listées par langage, pourquoi ne pas jeter Java dans le mix? Il n'y a pas grand-chose à jouer au golf ici, juste une simple boucle, mais j'ai pu en retirer quelques-uns de ma tentative initiale:
la source
s
(la somme totale) commence à1<<20
(le nombre de rouleaux). Cela équivaut à en ajouter un à chaque rouleau. Lorsque le randomiseur lance 0, ilMatlab, 24
Première soumission!
J'avais espéré faire usage de randi ([1,4], 1024), qui donne une matrice de 1048576 éléments, mais ensuite j'avais besoin d'une double somme, qui prend plus de caractères que cela.
En ce qui concerne la vitesse de course mentionnée dans la question,
timeit
me dit que le temps d'exécution est d'environ 0,031 secondes. Donc, presque instantanément.la source
Haskell, 73 octets
Usage:
la source
C #: 105 octets
la source
The *exclusive* upper bound of the range
donc il devrait être 5a
et en déplaçant l'new System.Random()
intérieur duSum
. Bien sûr, cela créera un nouveau àRandom
chaque fois, mais qui s'en soucie tant qu'il donne un résultat?PHP,
3837 octetsCela utilise une idée très simple: résumez-les tous!
De plus, j'ai remarqué que
1048576
c'est10000000000000000000
en binaire, équivalent à1<<20
.Voici le code:
Testez dans votre navigateur (avec de très légères modifications):
Afficher l'extrait de code
Toutes les modifications du code sont expliquées dans les commentaires.
la source
;
aprèsecho$v
Mathematica,
3027 octetsMathematica a des noms de fonction assez longs ...
la source
C, 57 octets
Ce code fonctionne ... une fois. Si jamais vous avez besoin de lancer à nouveau ces dés, vous devrez
srand(time(0))
y entrer, en ajoutant 14 octets.la source
srand(time(0))
? (Désolé, je n'utilise pas C.)rand
à la même valeur à chaque exécution.srand
amorce le RNG ettime(0)
obtient l'heure actuelle en secondes depuis 1970.a=b=1<<20
vous pouvez ignorer1+
, cela économise 4 octets.int
avantmain
n'est pas requis.t=0
, puist=t (...) +1
pour 1048576 fois: détrompez-vous! (voir ma réponse, éventuellement)PostgreSQL, 59 octets
J'admets le léger problème qui
random()
pourrait, en théorie, produire exactement zéro, auquel cas le jet de dé serait nul.la source
;
pour terminer la requête car c'est la seuleRubis, 32 octets
Sous une forme plus lisible:
Il crée une plage de 1 à 1048576, puis itère plusieurs fois sur le bloc. Chaque fois que le bloc est exécuté, la valeur de l'itération précédente est transmise en tant que
x
(initialement 0, la valeur par défaut pourinject
). À chaque itération, il calcule un nombre aléatoire entre 0 et 3 (inclus), en ajoute un pour simuler le roulement d'un d4 et l'ajoute au total.Sur ma machine, c'est assez rapide à exécuter (
0.25 real, 0.22 user, 0.02 sys
).Si vous avez installé Ruby, vous pouvez l'exécuter avec
ruby -e 'p (1..2**20).inject{|x|x+rand(4)+1}'
(ilp
est nécessaire de voir la sortie lorsqu'elle est exécutée de cette manière, omettez-la si vous ne vous en souciez pas ou exécutez-la simplement dans IRB où le résultat est imprimé à l'écran pour vous). Je l'ai testé sur Ruby 2.1.6.Merci à l'histocrate pour le hack twiddling qui remplace
x + rand(4) + 1
avecx-~rand(4)
.la source
x-~rand(4)
équivaut àx+rand(4)+1
.2**20
par4e10
.PARI / GP, 25 octets
Vraiment, pas besoin de jouer au golf ici - c'est la façon simple de faire le calcul en GP. Il fonctionne en 90 millisecondes sur ma machine. Le levage du
+1
permet d'économiser environ 20 millisecondes.Juste pour le plaisir: si l'on optimisait les performances dans PARI,
a un très petit nombre total d'opérations - si xorgens a besoin de ~ 27 cycles par mot 64 bits (quelqu'un peut-il le vérifier?), alors un processeur avec POPCNT ne devrait prendre qu'environ 0,5 cycle / bit, ou quelques centaines de microsecondes pour la finale nombre.
Cela devrait avoir des performances dans le pire des cas presque optimales parmi les méthodes utilisant des nombres aléatoires de qualité similaire ou supérieure. Il devrait être possible d'augmenter considérablement la vitesse moyenne en combinant des cas - peut-être un million de rouleaux à la fois - et en sélectionnant avec (essentiellement) un codage arithmétique .
la source
Javascript,
5553504741 octetsJe ne savais pas que les nombres non aléatoires étaient un irritant connu, donc je pense que je devrais poster une vraie solution. Ne voulait pas manquer de respect.
Commentaire: comme indiqué par d'autres ci-dessus, vous pouvez ignorer le +1 à chaque rouleau en commençant par le nombre de rouleaux dans votre réponse, et en n'ayant pas à écrire a = 0, i = 1 << 20 vous économisez deux octets, et 2 autres parce que vous n'ajoutez pas +1 à chaque lancer. La fonction parseInt fait la même chose que Math.floor mais est 2 caractères plus courte.
la source
a+=parseInt(Math.random()*4)
peut être raccourcia+=1+Math.random()*4&7
. Ce1+
n'est que si vous vous souciez s'il roule à 0 ou non.for(a=i=1<<20;i--;)a+=(Math.random()*4)|0
Clip 10 , 12 octets
Il faut environ 0,6 seconde pour fonctionner sur ma machine.
la source
Aller, 78 octets
Golfé
Travaille toujours dessus
Exécutez en ligne ici http://play.golang.org/p/pCliUpu9Eq
la source
Aller, 87 octets
Solution naïve
Exécutez en ligne ici: http://play.golang.org/p/gwP5Os7_Sq
En raison du fonctionnement du terrain de jeu Go, vous devez changer manuellement la graine (le temps est toujours le même)
la source
Commodore Basic, 37 octets
Substitutions PETSCII:
─
=SHIFT+E
,/
=SHIFT+N
,┌
=SHIFT+O
Durée d'exécution estimée basée sur des séries avec un nombre de dés inférieur: 4,25 heures.
Il est tentant d'essayer de jouer au golf sur deux octets en faisant
C
un entier, en obtenant l'arrondi implicite des nombres aléatoires. Cependant, la plage des nombres entiers dans Commodore Basic est de -32678 à 32767 - pas assez, lorsque la réponse médiane est 2621440.la source
PowerShell,
4137 octetsA pris ma machine 2 minutes 40 secondes
la source
Rubis,
5147 caractèresJ'ai regardé toutes les réponses avant de faire cela, et la
sum(2**20 times {randInt(4)})
stratégie a vraiment collé, alors j'ai utilisé cela.> <>, 76 caractères
Je ne sais pas si celui-ci fonctionne, car mon navigateur est tombé en panne lorsque j'ai essayé de le tester, mais voici l'interpréteur en ligne.
la source
Swift, 64 octets
Rien d'intelligent, jouer au golf à Swift est difficile ...
Version 2 (trop tard)
la source
Java (Java 8) - 52
la source