Death By Shock Probe: ça fait beaucoup de dés

20

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

SuperJedi224
la source
Attendez, dois-je donner la somme du jet de dés ou juste tous les jets d'une liste?
Maltysen
5
Votre question, dans son état actuel, sera probablement critiquée pour son manque de clarté ou pour être trop large. Il serait très utile que vous décriviez en termes spécifiques et objectifs comment les programmes seront notés et quelles méthodes les programmes devraient avoir à leur disposition. De plus, la notation de 1048576d4peut 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.
BrainSteel
2
Ce problème peut être résolu trop rapidement pour être un bon contre-la-montre.
isaacg
12
Vous pouvez essayer de créer un tableau de bord des extraits de pile pour éviter d'avoir à mettre à jour manuellement la liste des soumissions.
Alex A.
1
J'adore ce titre.
ASCIIThenANSI

Réponses:

10

Pyth - 9 8 octets

Utilise une méthode simple évidente de sommation de randint. Ça m'a pris minute à réaliser 1048576était 2^20, maintenant je me sens vraiment stupide. Merci à @Jakube de m'avoir sauvé un octet en le signalant 2^20 = 4^10.

smhO4^4T

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^10ci: Essayez-le en ligne ici .

s        Summation
 m       Map
  h      Incr (accounts for 0-indexed randint)
   O4    Randint 4
  ^4T    Four raised to ten
Maltysen
la source
4
8 octets sont possibles. 2^20 = 4^10
Jakube
@Jakube merci pour le conseil :)
Maltysen
Cela se termine immédiatement pour moi.
Carcigenicate
@Carcigenicate parlez-vous du lien que j'ai donné? C'est celui modifié, seulement des sommes 1024d4.
Maltysen
@Maltysen Oups, désolé. Ya, c'est ça.
Carcigenicate
9

Perl - 48 44 37 39 34 octets

$-+=rand(4)+1for(1..2**20);print$-

Imprime 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:

my $s = 0
$s += int( rand(4) + 1 ) for (1 .. 2**20);
print "$s";
ASCIIThenANSI
la source
C'était un peu difficile de brancher une minuterie, mais j'ai finalement réussi à la faire fonctionner.
SuperJedi224
2
Puisque nous ne nous soucions pas des avertissements ... $ s + = int rand (5) pour (1..2 ** 20); imprimer $ s
Thaylon
3
int(rand(5))renvoie la plage de 0 à 4 tandis que d4 devrait être de 1 à 4.
nutki
@nutki OK, merci. Je l'ai édité maintenant.
ASCIIThenANSI
$s+=int rand(4)+1for(1..2**20);print$sLa suppression de la parenthèse pour int fonctionne également pour moi, pour enregistrer un trait.
Caek
7

APL, 11 10 octets

+/?4⍴⍨2*20

Cela prend simplement la somme d'un tableau de 2 20 = 1048576 entiers aléatoires compris entre 1 et 4.

+/           ⍝ Reduce by summing a
  ?          ⍝ random integer
   4⍴⍨       ⍝ array with values between 1 and 4
      2*20   ⍝ of length 2^20

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!

Alex A.
la source
Un et 5 ??? Un d4 peut donner 1, 2, 3 ou 4. Vous ne pouvez pas obtenir 5.
Loren Pechtel
@ LorenPechtel: Désolé, ma mauvaise. Merci d'avoir fait remarquer cela. C'est réparé maintenant. J'ai le cerveau fatigué.
Alex A.
Enregistrer un octet:+/?4⍴⍨2*20
marinus
Petite amélioration: utilisez +/?4⍴⍨2*20plutôt.
FUZxxl
1
Incidemment, cette réponse n'est pas du tout gérée: elle serait écrite exactement de la même manière dans le code APL de production.
FUZxxl
7

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)

Σ (randInt (1,4), A, 1,2 ^ 20
SuperJedi224
la source
1
+1 pour l'avoir exécuté sur une TI-84. Je suppose que le temps n'est pas un problème ici, ce sont des calculatrices âgées de 30 à 40 ans.
ASCIIThenANSI
Je suppose qu'il y a une fonction pour échantillonner une distribution normale plutôt qu'une distribution uniforme? Cela devrait être beaucoup plus rapide.
Ben Voigt
@BenVoigt: Étant donné qu'il s'agit de simuler le roulement de dés, une distribution normale n'est pas appropriée; il faudrait que ce soit uniforme.
Alex A.
2
@AlexA .: Le théorème de limite centrale prévoit que la somme de nombreux dés uniformes ne peut pas être distinguée d'une distribution normale. Cela dépend donc de la façon dont nous sommes pédant quant à la "simulation du roulement".
Ben Voigt
1
@MIWright, je pensais que c'était juste pour la communication. Au moins celui que j'ai utilise des piles AAA.
Arturo Torres Sánchez
7

R, 32 24 23 21 octets

Edit: Débarrassé de la as.integerdivision 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=

sum(sample(4,2^20,T))

Testé avec

i = s = 0
repeat {
i = i + 1
print(sum(sample(4,2^20,r=T)))
s = s + system.time(sum(sample(4,2^20,r=T)))[3]
if (i == 10) break
}
print (s/10)

Les sorties

[1] 2621936
[1] 2620047
[1] 2621004
[1] 2621783
[1] 2621149
[1] 2619777
[1] 2620428
[1] 2621840
[1] 2621458
[1] 2620680
elapsed 
   0.029 

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.

sum(rmultinom(1,2^20,rep(1,4))*1:4)

Voici un chronométrage que j'ai fait sur ma machine

system.time(for(i in 1:1000000)sum(rmultinom(1,2^20,rep(1,4))*1:4))
                   user                  system                 elapsed 
7.330000000000040927262 0.000000000000000000000 7.370000000000345607987 
MickyT
la source
Vous pouvez enregistrer quelques octets en utilisant sample()à la place de runif(), à savoir sum(sample(4,2^20,r=T)).
Alex A.
Je viens de faire un benchmarking sur mon ordinateur et sample()c'est aussi plus rapide!
Alex A.
@AlexA. Merci de tester et de changer quand je me rapprocherai d'un ordinateur
MickyT
ne pas necro ceci ou quoi que ce soit mais vous n'avez pas besoin r=T, Tc'est bien pour le remplacement
Giuseppe
1
@Giuseppe, merci .. c'était vraiment un ancien
MickyT
6

Python 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 osbibliothèque semble économiser quelques caractères par rapport à l'utilisation de la randombibliothèque.

import os
print sum(1+ord(c)%4 for c in os.urandom(1<<20))

Cela prend environ 0,2 seconde sur mon PC.

Logic Knight
la source
6

CJam, 12 11 octets

YK#_{4mr+}*

C'est assez simple:

YK                  e# Y is 2, K is 20
  #                 e# 2 to the power 20
   _                e# Copy this 2 to the power 20. The first one acts as a base value
    {    }*         e# Run this code block 2 to the power 20 times
     4mr            e# Get a random int from 0 to 3. 0 to 3 works because we already have
                    e# 2 to the power 20 as base value for summation.
        +           e# Add it to the current sum (initially 2 to the power 20)

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

Optimiseur
la source
La version en ligne prend environ 6 secondes aux ordinateurs ici, mais c'est probablement juste le réseau et / ou les macbooks que l'école insiste pour utiliser. J'essaierai à nouveau à la maison.
SuperJedi224
@ SuperJedi224 La version en ligne est entièrement en JavaScript, ne fait aucun appel réseau. Vous pouvez télécharger la version Java et l'exécuter en suivant les instructions sur le site Web.
Optimizer
3
À moins que je manque quelque chose (ce qui est malheureusement trop courant avec CJam et moi), au lieu de semer avec 0 et d'ajouter 1 pour 2 ^ 20 runs, semer avec 2 ^ 20 pour économiser 1 octet:YK#_{4mr+}*
DocMax
@DocMax Vous avez raison. Merci!
Optimizer
+1; J'allais poster cette réponse exacte (sauf avec 4A#au lieu de YK#), mais vous m'avez battu. :)
Ilmari Karonen
6

JavaScript (ES6), 54 octets

Temps moyen <100 msec. Exécutez l'extrait de code pour tester (dans Firefox)

// This is the answer
f=t=>(i=>{for(t=i;i--;)t+=Math.random()*4|0})(1<<20)|t

// This is the test
test();

function test(){
  var time = ~new Date;
  var tot = f();
  time -= ~new Date;
  
  Out.innerHTML = "Tot: " + tot + " in msec: " + time + "\n" + Out.innerHTML;
}
<button onclick="test()">Repeat test</button><br>
<pre id=Out></pre>

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

f=()=>{
   var t = 0, r, i
   for (i=1<<20; i--; ) 
   {
      r = Math.random()*4 // random number between 0 and 3.9999999
      r = r + 1 // range 1 ... 4.999999
      r = r | 0 // truncate to int, so range 1 ... 4
      t = t+r
   }
   return t
}

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:

f=()=>{
   var t, r, i
   for (t = i = 1<<20; i--; ) 
   {
      r = Math.random()*4 // random number between 0 and 3.9999999
      r = r | 0 // truncate to int, so range 0 ... 3
      t = t+r
   }
   return t
}

Puis golf, supprimez la variable temp r et supprimez la déclaration des variables locales. test un paramètre, car il est nécessaire de raccourcir la déclaration de f. iest global (mauvaise chose)

f=t=>{
   for(t=i=1<<20;i--;) 
      t+=Math.random()*4|0
   return t
}

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

f=t=>(
  (i=>{ // start inner function body
     for(t=i;i--;)t=t+Math.random()*4|0 // assign t without returning it
   })(1<<20) // value assigned to parameter i
  | t // the inner function returns 'undefined', binary ored with t gives t again
) // and these open/close bracket can be removed too
edc65
la source
Ne fonctionne pas en chrome. Sur le point de tester en FF.
SuperJedi224
Bien sûr. Chrome est ES5
edc65
1
Il prend en charge ES6 (dont la plupart n'est disponible qu'en activant le javascript expérimental à partir des indicateurs chrome: \\), mais ne prend pas encore en charge les fonctions fléchées
SuperJedi224
5

Perl, 29

Génère un tableau de la longueur requise.

print~~map{0..rand 4}1..2**20
nutki
la source
Je reçois une erreur de syntaxe sur celui-ci.
SuperJedi224
Cela nécessite une version suffisamment nouvelle de Perl (l'opérateur smartmatch a été introduit en 5.10.1, et je pense qu'il n'a été mis à disposition par défaut que plus tard).
Mark
~~n'est pas un smartmatch, juste une inversion double bit pour forcer le contexte scalaire. Un chemin d'un caractère plus long serait print$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/LAIWzq
nutki
Oui, cela fonctionne sur IDEone. Je te le donnerai.
SuperJedi224
5

J (12 octets, environ 9,8 millisecondes)

+/>:?4$~2^20

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:

   timeit =: 13 : '(1000 * >./ ($/x) 6!:2"0 1 y)'
   4 20 timeit '+/>:?4$~2^20'
9.90059

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 .

ɐɔıʇǝɥʇuʎs
la source
4

Pyth, 10 octets

u+GhO4^4TZ

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

u     ^4TZ   start with G = 0, for H in 0, ... 4^10-1:
                G = 
 +GhO4              G + (rand_int(4) + 1)
             result is printed implicitly 
Jakube
la source
Testera cet après-midi.
SuperJedi224
4

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:

int f(){int i=1<<20,s=i;while(i-->0)s+=Math.random()*4;return s;}
Géobits
la source
Testera cet après-midi.
SuperJedi224
Aucun problème. Cela prend environ 80 ms sur ce PC (lent), mais je ne sais pas ce que vous utilisez pour le temps.
Geobits
Je ne pense pas que votre programme soit un modèle correct. Il peut et fait dans mes tests ajouter 0 sur certains rouleaux. Si je comprends bien, la plupart des d4 sont 1,2,3,4 (pas de 0 possible).
4
@ user39526 s(la somme totale) commence à 1<<20(le nombre de rouleaux). Cela équivaut à en ajouter un à chaque rouleau. Lorsque le randomiseur lance 0, il
obtient
Vous devriez passer à Java 8! codegolf.stackexchange.com/a/52919/7021
RobAu
4

Matlab, 24

Première soumission!

sum(randi([1,4],1,2^20))

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, timeitme dit que le temps d'exécution est d'environ 0,031 secondes. Donc, presque instantanément.

Oebele
la source
J'obtiens 0,04 à 0,05 seconde via l'octave en ligne.
SuperJedi224
4

Haskell, 73 octets

import System.Random
f=fmap sum.(sequence.replicate(2^20))$randomRIO(1,4)

Usage:

$ ghci sourcefile.hs
ghci> f
2622130
Zeta
la source
4

C #: 105 octets

using System.Linq;class C{int D(){var a=new System.Random();return new int[1<<20].Sum(i=>a.Next(1,5));}}
Andrew
la source
Sympa, j'aime ça même si c'est deux fois faux. C'est 1 << 20, pas 2 << 20. Et le deuxième paramètre de Random.Next est The *exclusive* upper bound of the rangedonc il devrait être 5
edc65
@ edc65 Merci d'avoir rattrapé ces erreurs. J'ai mis à jour la réponse.
Andrew
1
Vous pouvez enregistrer 9 caractères en éliminant aet en déplaçant l' new System.Random()intérieur du Sum. Bien sûr, cela créera un nouveau à Randomchaque fois, mais qui s'en soucie tant qu'il donne un résultat?
LegionMammal978
@ LegionMammal978 si vous créez un nouveau Random encore et encore, le résultat est principalement non aléatoire
edc65
@ edc65 C'est pourquoi je n'ai pas choisi cette voie. Je n'ai pas eu l'occasion de tester ce qui se passe si j'ai suivi la suggestion.
Andrew
4

PHP, 38 37 octets

Cela utilise une idée très simple: résumez-les tous!

De plus, j'ai remarqué que 1048576c'est 10000000000000000000en binaire, équivalent à 1<<20.

Voici le code:

while($i++<1<<20)$v+=rand(1,4);echo$v

Testez dans votre navigateur (avec de très légères modifications):

$i=$v=0;while($i++<1<<20)$v+=rand(1,4);printf($v);

Toutes les modifications du code sont expliquées dans les commentaires.

Ismael Miguel
la source
Vous pouvez supprimer l' ;aprèsecho$v
Martijn
@Martijn Je l'ai laissé là parce que la plupart du temps PHP s'en plaint. Mais je l'ai supprimé maintenant. Cela fonctionne sur sandbox.onlinephpfunctions.com et cela suffit.
Ismael Miguel,
4

Mathematica, 30 27 octets

Tr[RandomInteger[3,2^20]+1]

Mathematica a des noms de fonction assez longs ...

LegionMammal978
la source
3

C, 57 octets

main(a,b){for(b=a=1<<20;a--;b+=rand()%4);printf("%d",b);}

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.

Functino
la source
Pourquoi auriez-vous besoin d'ajouter srand(time(0))? (Désolé, je n'utilise pas C.)
ASCIIThenANSI
@ASCIIThenANSI De nombreuses implémentations de C l'amènent randà la même valeur à chaque exécution. srandamorce le RNG et time(0)obtient l'heure actuelle en secondes depuis 1970.
Functino
Si vous initialisez, a=b=1<<20vous pouvez ignorer 1+, cela économise 4 octets.
nutki
De plus, intavant mainn'est pas requis.
nutki
Astuce à quiconque le fait t=0, puis t=t (...) +1pour 1048576 fois: détrompez-vous! (voir ma réponse, éventuellement)
edc65
3

PostgreSQL, 59 octets

select sum(ceil(random()*4)) from generate_series(1,1<<20);

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.

Andrew
la source
Vous n'avez pas vraiment besoin de ;pour terminer la requête car c'est la seule
MickyT
3

Rubis, 32 octets

(1..2**20).inject{|x|x-~rand(4)}

Sous une forme plus lisible:

(1..2**20).inject(0) do |x|
  x + rand(4) + 1
end

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 pour inject). À 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}'(il pest 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) + 1avec x-~rand(4).

Haegin
la source
1
Pourriez-vous expliquer comment cela fonctionne?
ASCIIThenANSI
Le premier interprète en ligne que j'ai pu trouver qui veut réellement charger les affirmations selon lesquelles la méthode rand () n'existe pas. Je vais essayer d'en trouver un autre.
SuperJedi224
D'accord, j'en ai trouvé un qui fonctionne.
SuperJedi224
Hack twiddling: x-~rand(4)équivaut à x+rand(4)+1.
histocrate
Vous pouvez également remplacer 2**20par 4e10.
histocrate
3

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 +1permet d'économiser environ 20 millisecondes.

sum(i=1,2^20,random(4)+1)

Juste pour le plaisir: si l'on optimisait les performances dans PARI,

inline long sum32d4(void) {
  long n = rand64();
  // Note: __builtin_popcountll could replace hamming_word if using gcc
  return hamming_word(n) + hamming_word(n & 0xAAAAAAAAAAAAAAAALL);
}

long sum1048576d4(void) {
  long total = 0;
  int i;
  for(i=0; i<32768; i++) total += sum32d4();
  return total;
}

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 .

Charles
la source
3

Javascript, 55 53 50 47 41 octets

for(a=i=1<<20;i--;)a+=(Math.random()*4)|0

Je 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.

Ralph Marshall
la source
Notez que cette réponse est complètement différente de celle initialement commentée par SuperJedi224 et @Andrew
Ralph Marshall
Vous pouvez supprimer les deux crochets et le dernier point-virgule (et seulement le dernier) pour couper quelques caractères supplémentaires. De plus, la version actuelle ne compte que 50 caractères, pas 52.
SuperJedi224
SuperJedi - merci pour les suggestions. Je pensais l'avoir essayé sans les crochets uniquement pour rencontrer des problèmes, mais peut-être que j'avais un problème différent. En tout cas, je pense que c'est à peu près aussi bon que ça va l'être.
Ralph Marshall
a+=parseInt(Math.random()*4)peut être raccourci a+=1+Math.random()*4&7. Ce 1+n'est que si vous vous souciez s'il roule à 0 ou non.
Ismael Miguel
Vous pouvez for(a=i=1<<20;i--;)a+=(Math.random()*4)|0
jouer au
2

Clip 10 , 12 octets

r+`m[)r4}#WT

         #4T    .- 4^10 = 1048576             -.
   m[   }       .- that many...               -.
     )r4        .-          ...random numbers -.
r+`             .- sum                        -.

Il faut environ 0,6 seconde pour fonctionner sur ma machine.

Ypnypn
la source
2

Aller, 78 octets

Golfé

import."math/rand";func r()(o int){for i:=2<<19;i>=0;i--{o+=Intn(4)+1};return}

Travaille toujours dessus

Exécutez en ligne ici http://play.golang.org/p/pCliUpu9Eq

Kristoffer Sall-Storgaard
la source
Malheureusement, le terrain de jeu golang.org n'implémente pas correctement les opérations de temps et celui de repl.it ne veut pas se charger pour le moment. Je verrai ce que je peux faire à ce sujet cet après-midi.
SuperJedi224
2

Aller, 87 octets

Solution naïve

import"math/rand";func r(){o,n:=0,2<<19;for i:=0;i<n;i++{o+=rand.Intn(4)};println(o+n)}

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)

Kristoffer Sall-Storgaard
la source
2

Commodore Basic, 37 octets

1F┌I=1TO2↑20:C=C+INT(R/(1)*4+1):N─:?C

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 Cun 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.

marque
la source
2

PowerShell, 41 37 octets

1..1mb|%{(get-random)%4+1}|measure -s

A pris ma machine 2 minutes 40 secondes

Nacht - Rétablir Monica
la source
2

Rubis, 51 47 caractères

x=[];(2**20).times{x<<rand(4)+1};p x.inject(:+)

J'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

012a*&>2*&1v
|.!33&^?&:-<
3.v < >-:v >
   vxv1v^<;3
  1234    n+
  >>>> >?!^^

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.

taper
la source
Je vous donnerai un +1 pour la réponse> <>.
SuperJedi224
2

Swift, 64 octets

Rien d'intelligent, jouer au golf à Swift est difficile ...

func r()->Int{var x=0;for _ in 0..<(2<<19) {x+=Int(arc4random()%4)+1;};return x;}

Version 2 (trop tard)

var x=0;for _ in 0..<(2<<19){x+=Int(arc4random()%4)+1;};print(x)
GoatInTheMachine
la source
2

Java (Java 8) - 52

int f(){return new Random().ints(1<<20,1,5).sum();}
RobAu
la source