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

Programmé marqué ** Je n'ai pas encore pu tester correctement

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

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";

APL, 11 10 octets

+/?4⍴⍨2*20

Cela prend simplement la somme d'un tableau de 2 ²⁰ = 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!

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

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 

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.

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

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

Perl, 29

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

print~~map{0..rand 4}1..2**20

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 .

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 

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;}

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.

Haskell, 73 octets

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

Usage:

$ ghci sourcefile.hs
ghci> f
2622130

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));}}

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);

//'patch' to make a TRUE polyglot, to work in JS

if('\0'=="\0")//this will be false in PHP, true in JS
{
  //rand function, takes 2 parameters
  function rand($m,$n){
    return ((Math.random()*($n-$m+1))+$m)>>0;
    
    /*
     *returns an integer number between $m and $n
     *example run, with rand(4,9):
     *(Math.random()*(9-4+1))+4
     *
     *if you run Math.random()*(9-4+1),
     *it will returns numbers between 0 and 5 (9-4+1=6, but Math.random() never returns 1)
     *but the minimum is 4, so, we add it in the end
     *this results in numbers between 0+4 and 4+5
     *
     */
    
  }
  
  //for this purpose, this is enough
  function printf($s){
    document.write($s);
  }
}


/*
 *Changes:
 *
 *- instead of echo, use printf
 *    printf outputs a formatted string in php
 *    if I used echo instead, PHP would complain
 *- set an initial value on $i and $v
 *    this avoids errors in Javascript
 *
 */


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

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

Mathematica, 30 27 octets

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

Mathematica a des noms de fonction assez longs ...

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.

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.

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

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 .

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.

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.

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

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)

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.

PowerShell, 41 37 octets

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

A pris ma machine 2 minutes 40 secondes

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.

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)

Java (Java 8) - 52

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