No webcomic Darths & Droids , Pete, que interpreta R2-D2 na campanha de roleplay ficcional em torno da qual o gibi se baseia, uma vez afirma (aviso: possíveis spoilers no gibi vinculado) que, com o Lost Orb de Phanastacoria, equipado com seu sonda de choque, ele agora pode distribuir uma enorme quantidade de 1048576d4de dano. (O GM não confirmou nem negou isso.) Como deve ser razoavelmente óbvio que quase ninguém terá paciência para jogar tantos dados, escreva um programa de computador para fazer isso por ele, produzindo o valor total acumulado de alguma maneira razoável. formato. As inscrições serão classificadas por tamanho do programa (programa mais curto, por contagem de bytes, vitórias), tanto no geral quanto no idioma, com o tempo de execução interrompendo os vínculos. A resposta pode ser um programa completo ou uma definição de função.

Pontuações por idioma

Pyth

Maltysen - 8 bytes *

Jakube - 10 bytes

APL

Alex A - 10 bytes

CJam

Otimizador - 11 bytes

J

--ıʇǝɥʇuʎs - 12 bytes **

Clip10

Ypnypn - 12 bytes **

K

JohnE - 13 bytes

Ti-84 BASIC

SuperJedi224 - 17 bytes *

R

MickyT - 23 bytes

OCTAVE / MATLAB

Oebele - 24 bytes

PARI / GP

Charles - 25 bytes **

Wolfram / Mathematica

LegionMammal978 - 27 bytes

Perl

Nutki - 29 bytes

AsciiThenAnsii - 34 bytes

Rubi

Haegin - 32 bytes **

ConfusedMr_C - 51 bytes **

Commodore Basic

Marca - 37 bytes **

PHP

Ismael Miguel - 38 bytes

VBA

Sean Cheshire - 40 bytes **

PowerShell

Nacht - 41 bytes **

Javascript

Ralph Marshall - 41 bytes

edc65 - 54 bytes (requer a funcionalidade ES6 não disponível em todos os navegadores.)

Lua

criptyty - 51 bytes

Java

RobAu - 52 bytes **

Geobits - 65 bytes

C

Functino - 57 bytes

Python

CarpetPython - 58 bytes

Postgre / SQL

Andrew - 59 bytes **

Rápido

Skrundz - 69 bytes

GoatInTheMachine - 81 bytes

Haskell

Zeta - 73 bytes **

ActionScript

Brian - 75 bytes **

> <>

ConfusedMr_C - 76 bytes

VAI

Kristoffer Sall-Storgaard - 78 bytes

C #

Brandon - 91 bytes **

Andrew - 105 bytes

Ewan - 148 bytes

coçar, arranhão

SuperJedi224 - 102 bytes

C ++

Michelfrancis Bustillos - 154 bytes

Poliglotas

Ismael Miguel (Javascript / ActionScript2) - 67 bytes

Top 10 no geral

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

Programado marcado ** Ainda não consegui testar corretamente

Pitão - 9 8 bytes

Usa método simples óbvio de somatório de randint. Levei minuto para perceber 1048576era 2^20, agora eu me sinto realmente estúpido. Obrigado a @Jakube por me salvar um byte, apontando 2^20 = 4^10.

smhO4^4T

O tempo de execução é horrível, ainda não foi concluído no meu computador; portanto, não faz sentido executá-lo on-line; então, esse é o seguinte 2^10: Experimente on-line aqui .

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 bytes

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

Imprime a soma sem uma nova linha à direita.
Economizou 4 bytes substituindo 2**20(obrigado Maltysen) e removendo aspas na impressão.
Salvei mais 7 bytes reorganizando o código (obrigado Thaylon!)
Perdi 2 bytes porque meu código antigo gerou 0-4 (deve ser 1-4).
Mais uma vez, salvou 5 bytes graças a Caek e nutki.

Código não-jogado e escrito corretamente:

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

APL, 11 10 bytes

+/?4⍴⍨2*20

Isso leva a soma de uma matriz de 2 ²⁰ = 1048576 números aleatórios entre 1 e 4.

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

Você pode avaliar isso no TryAPL imprimindo o carimbo de data e hora antes e depois. Demora cerca de 0,02 segundos.

Guardou um byte graças a marinus e FUZxxl!

Ti-84 Básico, 17 bytes

Área total - Tamanho do cabeçalho do programa = 17 bytes

Tempo de execução: desconhecido, estimado em 5-6 horas, com base no desempenho para números menores de rolos (portanto, basicamente, não é muito bom)

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

R, 32 24 23 21 bytes

Edit: Livre-se da as.integerdivisão inteira e usada %/%. Acelere um pouco.

Agradecimentos a Alex A pela dica de amostra ... e Giuseppe por remover o r=

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

Testado com

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)

Saídas

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

Para velocidade pura, o seguinte é concluído em microssegundos. No entanto, não tenho certeza se minha lógica está correta. Os resultados parecem consistentes com o método aleatório. Pena que é um comprimento maior.

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

Aqui está uma corrida de tempo que fiz na minha máquina

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 bytes

Obtemos 1048576 caracteres aleatórios do sistema operacional, pegamos 2 bits de cada e os somamos. O uso da osbiblioteca parece salvar alguns caracteres sobre o uso da randombiblioteca.

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

Isso leva cerca de 0,2 segundos no meu PC.

CJam, 12 11 bytes

YK#_{4mr+}*

Isso é bem direto:

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)

Mas a beleza disso é que também é muito rápido! Na minha máquina (e usando o compilador Java ), leva em média 70 milissegundos.

A versão online leva cerca de 1,7 segundos na minha máquina.

Atualização : 1 byte salvo graças ao DocMax

JavaScript (ES6), 54 bytes

Tempo médio <100 ms. Execute o snippet para testar (no 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>

Explicação

Sem pacote estatístico incorporado, em Javascript, a maneira mais curta de obter a soma de 1 milhão de números aleatórios é chamar random () por um milhão de vezes. Tão simplesmente

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
}

Agora, adicionar 1 por um milhão de vezes é exatamente o mesmo que adicionar 1 milhão, ou melhor ainda, iniciar a soma com 1 milhão e depois adicionar o restante:

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
}

Em seguida, golf, solte a variável temp r e solte a declaração das variáveis ​​locais. té um parâmetro, pois é necessário reduzir a declaração de f.ié global (coisa ruim)

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

Em seguida, encontre uma maneira de evitar o 'retorno' usando uma função interna sem nome. Como efeito colateral, obtemos outro parâmetro para que não sejam usados ​​globais

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

Gera uma tabela do comprimento necessário.

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

J (12 bytes, cerca de 9,8 milissegundos)

+/>:?4$~2^20

Eu suspeito que isso seja principalmente limitado à largura de banda de memória: eu não consigo fazer isso no máximo com um único núcleo ...

Você pode testar isso com o seguinte código:

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

Isso o executa em 4 grupos de 20 trilhas e retorna o número de milissegundos do tempo médio no grupo mais rápido. Um intérprete pode ser encontrado aqui .

Pitão, 10 bytes

u+GhO4^4TZ

Isso tem um pouco mais de bytes do que a solução Pyth da @ Maltysen. Mas ele roda em 8,5 segundos no meu laptop, enquanto a solução da @ Maltysen não produziu solução em 20 minutos.

Mas ainda é um pouco lento demais para o compilador online.

Explicação

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

Como temos pontuações listadas por idioma, por que não jogar Java na mistura? Não há muito para jogar aqui, apenas um loop simples, mas consegui extrair alguns da minha tentativa inicial:

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

Matlab, 24

Primeira submissão de todos os tempos!

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

Eu esperava usar randi ([1,4], 1024), que fornece uma matriz de 1048576 elementos, mas então eu precisava de uma soma dupla, que requer mais caracteres que isso.

Em relação à velocidade de execução mencionada na pergunta, timeito tempo de execução é de cerca de 0,031 segundos. Então, praticamente instantâneo.

Haskell, 73 bytes

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

Uso:

$ 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

Isso usa uma idéia muito simples: soma todos eles!

Além disso, notei que isso 1048576é 10000000000000000000binário, equivalente a 1<<20.

Aqui está o código:

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

Teste no seu navegador (com alterações MUITO PEQUENAS ):

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

Todas as alterações no código são explicadas nos comentários.

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