Nel webcomic Darths & Droids , Pete, che interpreta R2-D2 nella campagna di gioco di ruolo immaginaria su cui si basa il fumetto, una volta afferma (avvertimento: potenziali spoiler nel fumetto collegato) che, con la Sfera perduta di Phanastacoria truccata fino al suo sonda d'urto, ora può lanciare un enorme 1048576d4di danno. (Il GM non ha né confermato né negato questo.) Dato che dovrebbe essere ragionevolmente ovvio che quasi nessuno avrà effettivamente la pazienza di tirare tanti dadi, scrivere un programma per farlo per lui, producendo il valore totale ottenuto in modo ragionevole formato. Le voci saranno classificate in base alle dimensioni del programma (programma più breve, numero di byte, vincite), sia generali che per lingua, con vincoli di runtime. La risposta può essere un programma completo o una definizione di funzione.

Punteggi per lingua

Pyth

Maltysen - 8 byte *

Jakube - 10 byte

APL

Alex A - 10 byte

CJam

Ottimizzatore - 11 byte

J

ɐɔıʇǝɥʇuʎs - 12 byte **

Clip10

Ypnypn - 12 byte **

K

JohnE - 13 byte

Ti-84 BASIC

SuperJedi224 - 17 byte *

R

MickyT - 23 byte

Ottava / MATLAB

Oebele - 24 byte

PARI / GP

Charles - 25 byte **

Wolfram / Mathematica

LegionMammal978 - 27 byte

Perl

Nutki - 29 byte

AsciiThenAnsii - 34 byte

Rubino

Haegin - 32 byte **

ConfusedMr_C - 51 byte **

Commodore Basic

Mark - 37 byte **

PHP

Ismael Miguel - 38 byte

VBA

Sean Cheshire - 40 byte **

PowerShell

Nacht - 41 byte **

Javascript

Ralph Marshall - 41 byte

edc65 - 54 byte (richiede la funzionalità ES6 non disponibile in tutti i browser.)

Lua

criptico - 51 byte

Giava

RobAu - 52 byte **

Geobit - 65 byte

C

Functino - 57 byte

Pitone

CarpetPython - 58 byte

Postgre / SQL

Andrew - 59 byte **

veloce

Skrundz - 69 byte

GoatInTheMachine - 81 byte

Haskell

Zeta - 73 byte **

ActionScript

Brian - 75 byte **

> <>

ConfusedMr_C - 76 byte

PARTIRE

Kristoffer Sall-Storgaard - 78 byte

C #

Brandon - 91 byte **

Andrew - 105 byte

Ewan - 148 byte

Graffiare

SuperJedi224 - 102 byte

C ++

Michelfrancis Bustillos - 154 byte

poliglotti

Ismael Miguel (Javascript / ActionScript2) - 67 byte

Top 10 in generale

Maltysen
Alex A
Jakube
Optimizer
ɐɔıʇǝɥʇuʎs / Ypnypn (ordine incerto)
JohnE
SuperJedi224
MickyT
Oebele

Programmato contrassegnato ** Non sono ancora stato in grado di testare correttamente

Pyth - 9 8 byte

Utilizza un metodo ovvio e semplice di sommatoria di randint. Mi ci è voluto un minuto per capire che lo 1048576era2^20 , ora mi sento veramente stupido. Grazie a @Jakube per avermi salvato un byte sottolineando 2^20 = 4^10.

smhO4^4T

Il runtime è orribile, deve ancora finire sul mio computer, quindi non ha senso eseguirlo online quindi ecco 2^10quello: provalo online qui .

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 byte

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

Stampa la somma senza una nuova riga finale.
Salvato 4 byte sostituendo 2**20(grazie Maltysen) e rimuovendo le virgolette attorno alla stampa.
Ho salvato altri 7 byte riorganizzando il codice (grazie Thaylon!) Ho
perso 2 byte perché il mio vecchio codice ha generato 0-4 (dovrebbe essere 1-4).
Ancora una volta, salvato 5 byte grazie a Caek e nutki.

Codice non scritto, correttamente scritto:

my $s = 0
$s += int( rand(4) + 1 ) for (1 .. 2**20);
print "$s";

APL, 11 10 byte

+/?4⍴⍨2*20

Questo prende semplicemente la somma di un array di 2 ²⁰ = 1048576 numeri interi casuali tra 1 e 4.

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

È possibile eseguire il benchmark di questo su TryAPL stampando il timestamp prima e dopo. Ci vogliono circa 0,02 secondi.

Salvataggio di un byte grazie a Marinus e FUZxxl!

Ti-84 Basic, 17 byte

Impronta totale - Dimensione dell'intestazione del programma = 17 byte

Tempo di esecuzione: sconosciuto, stimato in 5-6 ore base alle prestazioni per un numero inferiore di rotoli (quindi, sostanzialmente, non molto buono)

Σ (randInt (1,4), A, 1,2 ^ 20

R, 32 24 23 21 byte

Modifica: Elimina la as.integerdivisione intera utilizzata %/%. Accelera leggermente.

Grazie ad Alex A per il suggerimento del campione ... e Giuseppe per aver rimosso il file r=

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

Testato con

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)

Uscite

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

Per una velocità pura, quanto segue viene completato in microsecondi. Tuttavia non sono sicuro di avere la mia logica corretta per questo. I risultati sembrano coerenti con il metodo casuale. Peccato che sia una lunghezza più lunga.

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

Ecco una sequenza temporale che ho fatto sulla mia macchina

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 byte

Otteniamo 1048576 caratteri casuali dal sistema operativo, prendiamo 2 bit di ciascuno e li sommiamo. L'uso della oslibreria sembra salvare alcuni caratteri rispetto all'uso della randomlibreria.

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

Questo richiede circa 0,2 secondi sul mio PC.

CJam, 12 11 byte

YK#_{4mr+}*

Questo è piuttosto diretto:

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)

Ma il bello è che è anche molto veloce! Sulla mia macchina (e usando il compilatore Java ) ci vogliono in media 70 millisecondi.

La versione online impiega circa 1,7 secondi sul mio computer.

Aggiornamento : 1 byte salvato grazie a DocMax

JavaScript (ES6), 54 byte

Tempo medio <100 msec. Esegui snippet per testare (in 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>

Spiegazione

Senza pacchetto statistico integrato, in Javascript il modo più breve per ottenere la somma di 1 milione di numeri casuali è chiamare random () per un milione di volte. Così semplicemente

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
}

Ora, l'aggiunta di 1 per un milione di volte è esattamente la stessa dell'aggiunta di 1 milione o, ancora meglio, inizia la somma con 1 milione e poi aggiungi il resto:

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
}

Quindi golf, rilascia la variabile temp r e rilascia la dichiarazione delle variabili locali. tè un parametro, poiché è necessario accorciare la dichiarazione di f. iè globale (cosa negativa)

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

Quindi trova un modo per evitare il "ritorno" usando una funzione interna senza nome. Come effetto collaterale, otteniamo un altro parametro, quindi non vengono utilizzati globali

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

Genera una tabella della lunghezza richiesta.

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

J (12 byte, circa 9,8 millisecondi)

+/>:?4$~2^20

Ho il sospetto che questo sia principalmente un limite di memoria limitato: non riesco nemmeno a ottenere il massimo da un singolo core ...

Puoi testarlo con il seguente codice:

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

Questo lo esegue in 4 gruppi di 20 tracce e restituisce il numero di millisecondi del tempo medio nel gruppo più veloce. Un interprete può essere trovato qui .

Pyth, 10 byte

u+GhO4^4TZ

Questo ha un numero leggermente maggiore di byte rispetto alla soluzione Pyth di @ Maltysen. Ma funziona in 8,5 secondi sul mio laptop, mentre la soluzione di @ Maltysen non ha prodotto soluzione in 20 minuti di funzionamento.

Ma ancora un po 'troppo lento per il compilatore online.

Spiegazione

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

Since we have scores listed by language, why not throw Java into the mix? There's not much to golf here, just a simple loop, but I was able to squeeze a couple out of my initial attempt:

int f(){int i=1<<20,s=i;while(i-->0)s+=Math.random()*4;return s;}

Matlab, 24

First submission ever!

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

I had hoped to make use of randi([1,4],1024), which gives a matrix of 1048576 elements, but then I needed a double sum, which takes more characters than this.

Regarding the running speed mentioned in the question, timeit tells me the runtime is about 0.031 seconds. So, pretty much instant.

Haskell, 73 bytes

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

Usage:

$ ghci sourcefile.hs
ghci> f
2622130

C#: 105 bytes

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 bytes

This uses a very simple idea: sum them all!

Also, I've noticed that 1048576 is 10000000000000000000 in binary, equivalent to 1<<20.

Here's the code:

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

Test in your browser (with VERY LITTLE changes):

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

All the changes in the code are explained in comments.

Mathematica, 30 27 bytes

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

Mathematica has quite long function names...

C, 57 bytes

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

This code works... once. If you ever need to roll those dice again, you'll need to put srand(time(0)) in there, adding 14 bytes.

PostgreSQL, 59 bytes

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

I'll admit to the slight problem that random() could, in theory, produce exactly zero, in which case the die roll would be zero.

Ruby, 32 bytes

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

In a more readable form:

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

It creates a range from 1 to 1048576 and then iterates over the block that many times. Each time the block is executed the value from the previous iteration is passed in as x (initially 0, the default for inject). Each iteration it calculates a random number between 0 and 3 (inclusive), adds one so it simulates rolling a d4 and adds that to the total.

On my machine it's pretty fast to run (0.25 real, 0.22 user, 0.02 sys).

If you've got Ruby installed you can run it with ruby -e 'p (1..2**20).inject{|x|x+rand(4)+1}' (the p is necessary to see the output when run in this manner, omit it if you don't care for that or just run it inside IRB where the result is printed to the screen for you). I've tested it on Ruby 2.1.6.

Thanks to histocrat for the bit twiddling hack that replaces x + rand(4) + 1 with x-~rand(4).

PARI/GP, 25 bytes

Really, no need for golfing here -- this is the straightforward way of doing the calculation in GP. It runs in 90 milliseconds on my machine. Hoisting the +1 saves about 20 milliseconds.

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

Just for fun: if one were optimizing for performance in 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;
}

has a very small total operation count -- if xorgens needs ~27 cycles per 64-bit word (can anyone verify this?), then a processor with POPCNT should take only about 0.5 cycle/bit, or a few hundred microseconds for the final number.

This should have close-to-optimal worst-case performance among methods using random numbers of similar or higher quality. It should be possible to greatly increase average speed by combining cases -- maybe a million rolls at a time -- and selecting with (essentially) arithmetic coding.

Javascript, 55 53 50 47 41 bytes

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

I didn't realize that non-random numbers were a known irritant, so I figure that I ought to post a real solution. Meant no disrespect.

Commentary: as noted by others above you can skip the +1 to each roll by starting off with the number of rolls in your answer, and by not having to write a=0,i=1<<20 you save two bytes, and another 2 because you don't add +1 to each roll. The parseInt function does the same thing as Math.floor but is 2 characters shorter.

Clip 10, 12 bytes

r+`m[)r4}#WT

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

It takes approximately 0.6 seconds to run on my machine.

Go, 78 bytes

Golfed

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

Still working on it

Run online here http://play.golang.org/p/pCliUpu9Eq

Go, 87 bytes

Naive solution

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

Run online here: http://play.golang.org/p/gwP5Os7_Sq

Due to the way the Go playground works you have to manually change the seed (time is always the same)

Commodore Basic, 37 bytes

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

PETSCII substitutions: ─ = SHIFT+E, / = SHIFT+N, ┌ = SHIFT+O

Estimated runtime based on runs with lower dice counts: 4.25 hours.

It's tempting to try to golf off two bytes by making C an integer, getting implicit rounding of the random numbers. However, the range on integers in Commodore Basic is -32678 to 32767 -- not enough, when the median answer is 2621440.

PowerShell, 41 37 bytes

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

Took my machine 2 minutes 40 seconds

Ruby, 51 47 chars

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

I looked at all of the answers before I did this, and the sum(2**20 times {randInt(4)}) strategy really stuck out, so I used that.

><>, 76 chars

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

I'm not sure if this one works, because my browser crashed when I tried to test it, but here's the online interpreter.

Swift, 64 bytes

Nothing clever, golfing in Swift is hard...

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

Version 2 (too late)

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