Dalam webcomic Darths & Droids , Pete, yang memerankan R2-D2 dalam kampanye roleplaying fiktif yang menjadi dasar komiknya, pernah mengklaim (peringatan: spoiler potensial dalam komik terkait) yang, dengan Lost Orb of Phanastacoria yang disesuaikan dengan bukunya Probe shock, ia sekarang bisa mengeluarkan 1048576d4 kekalahankerusakan. (GM tidak membenarkan atau menyangkal hal ini.) Karena seharusnya cukup jelas bahwa hampir tidak ada yang benar-benar akan memiliki kesabaran untuk melempar dadu sebanyak itu, tulis sebuah program komputer untuk melakukannya untuknya, mengeluarkan total nilai yang digulirkan dalam beberapa hal yang masuk akal format. Entri akan diberi peringkat berdasarkan ukuran program (program terpendek, dengan jumlah byte, menang), baik keseluruhan maupun per-bahasa, dengan run time breaking ties. Jawaban dapat berupa program lengkap atau definisi fungsi.

Skor Per-Bahasa

Pyth

Maltysen - 8 byte *

Jakube - 10 byte

APL

Alex A - 10 byte

CJam

Pengoptimal - 11 byte

J

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

Klip10

Ypnypn - 12 byte **

K

JohnE - 13 byte

Ti-84 BASIC

SuperJedi224 - 17 byte *

R

MickyT - 23 byte

OCTAVE / MATLAB

Oebele - 24 byte

PARI / GP

Charles - 25 byte **

Wolfram / Mathematica

LegionMammal978 - 27 byte

Perl

Nutki - 29 byte

AsciiThenAnsii - 34 byte

Rubi

Haegin - 32 byte **

ConfusedMr_C - 51 byte **

Commodore Basic

Tandai - 37 byte **

PHP

Ismael Miguel - 38 byte

VBA

Sean Cheshire - 40 byte **

PowerShell

Nacht - 41 byte **

Javascript

Ralph Marshall - 41 byte

edc65 - 54 bytes (Membutuhkan fungsionalitas ES6 tidak tersedia di semua browser.)

Lua

cryptych - 51 byte

Jawa

RobAu - 52 byte **

Geobits - 65 byte

C

Functino - 57 byte

Python

CarpetPython - 58 byte

Postgre / SQL

Andrew - 59 byte **

Cepat

Skrundz - 69 byte

GoatInTheMachine - 81 byte

Haskell

Zeta - 73 byte **

ActionScript

Brian - 75 byte **

> <>

ConfusedMr_C - 76 byte

PERGI

Kristoffer Sall-Storgaard - 78 byte

C #

Brandon - 91 byte **

Andrew - 105 byte

Ewan - 148 byte

Menggaruk

SuperJedi224 - 102 byte

C ++

Michelfrancis Bustillos - 154 byte

Poliglot

Ismael Miguel (Javascript / ActionScript2) - 67 byte

10 Besar Keseluruhan

Maltysen
Alex A
Jakube
Pengoptimal
ɐɔıʇǝɥʇuʎs / Ypnypn (pesanan tidak pasti)
JohnE
SuperJedi224
MickyT
Oebele

Diprogram bertanda ** Saya belum dapat menguji dengan benar

Pyth - 9 8 byte

Menggunakan metode penjumlahan randint yang jelas dan sederhana. Butuh waktu beberapa menit untuk saya sadari 1048576adalah 2^20, sekarang saya merasa benar-benar bodoh. Terima kasih kepada @Jakube karena telah menyelamatkan saya satu byte dengan menunjukkan 2^20 = 4^10.

smhO4^4T

Runtime itu mengerikan, belum selesai di komputer saya, jadi tidak ada gunanya menjalankannya secara online, jadi inilah masalahnya2^10 : Coba online di sini .

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

Mencetak jumlah tanpa baris baru.
Disimpan 4 byte dengan menggantikan 2**20(terima kasih Maltysen) dan menghapus tanda kutip di cetak.
Menyimpan 7 byte lainnya dengan mengatur ulang kode (terima kasih Thaylon!)
Kehilangan 2 byte karena kode lama saya menghasilkan 0-4 (seharusnya 1-4).
Sekali lagi, disimpan 5 byte berkat Caek dan nutki.

Kode tidak tertulis, ditulis dengan benar:

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

APL, 11 10 byte

+/?4⍴⍨2*20

Ini hanya mengambil jumlah array 2 ²⁰ = 1048576 bilangan bulat acak antara 1 dan 4.

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

Anda dapat membandingkan ini di TryAPL dengan mencetak stempel waktu sebelum dan sesudah. Dibutuhkan sekitar 0,02 detik.

Menyimpan satu byte berkat marinus dan FUZxxl!

Ti-84 Basic, 17 byte

Total jejak - Ukuran tajuk program = 17 byte

Durasi: Tidak diketahui, diperkirakan 5-6 jam berdasarkan kinerja untuk jumlah gulungan yang lebih kecil (jadi, pada dasarnya, tidak terlalu baik)

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

R, 32 24 23 21 byte

Sunting: Singkirkan as.integerdivisi integer yang digunakan dan%/% . Percepat sedikit.

Terima kasih kepada Alex A untuk tip sampel ... dan Giuseppe untuk menghapus r=

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

Diuji dengan

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)

Keluaran

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

Untuk kecepatan murni berikut ini selesai dalam mikrodetik. Namun saya tidak yakin logika saya benar untuk itu. Hasilnya tampak konsisten dengan metode acak. Malu itu lebih panjang.

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

Inilah waktu yang saya lakukan pada mesin saya

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

Kami mendapatkan 1048576 karakter acak dari sistem operasi, ambil masing-masing 2 bit, dan tambahkan. Menggunakan osperpustakaan tampaknya menyimpan beberapa karakter daripada menggunakan randomperpustakaan.

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

Ini memakan waktu sekitar 0,2 detik pada PC saya.

CJam, 12 11 byte

YK#_{4mr+}*

Ini foward cukup lurus:

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)

Tetapi keindahan dari ini adalah sangat cepat juga! Di mesin saya (dan menggunakan kompiler Java ) dibutuhkan rata-rata 70 milidetik.

Versi online membutuhkan sekitar 1,7 detik di mesin saya.

Pembaruan : 1 byte disimpan berkat DocMax

JavaScript (ES6), 54 byte

Waktu rata-rata <100 msec. Jalankan cuplikan untuk menguji (di 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>

Penjelasan

Tanpa paket statistik bawaan, dalam Javascript cara terpendek untuk mendapatkan jumlah 1 juta nomor acak adalah dengan memanggil acak () sebanyak sejuta kali. Sangat sederhana

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
}

Sekarang, menambahkan 1 untuk satu juta kali sama persis dengan menambahkan 1 juta, atau bahkan lebih baik, mulai jumlah dengan 1 juta dan kemudian tambahkan sisanya:

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
}

Kemudian golf, drop variabel temp r dan drop deklarasi variabel lokal. tadalah parameter, karena diperlukan untuk mempersingkat deklarasi f. ibersifat global (hal buruk)

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

Kemudian temukan cara untuk menghindari 'kembali' menggunakan fungsi batin tanpa nama. Sebagai efek samping, kami mendapatkan parameter lain sehingga tidak ada global yang digunakan

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

Menghasilkan tabel dengan panjang yang dibutuhkan.

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

J (12 byte, sekitar 9,8 milidetik)

+/>:?4$~2^20

Saya curiga ini sebagian besar terbatas pada memory bandwith: Saya bahkan tidak bisa memaksimalkannya dengan single core ...

Anda dapat menguji ini dengan kode berikut:

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

Ini dijalankan dalam 4 grup dengan 20 jalur, dan mengembalikan jumlah milidetik dari waktu rata-rata dalam grup tercepat. Seorang juru bahasa dapat ditemukan di sini .

Pyth, 10 byte

u+GhO4^4TZ

Ini memiliki sedikit lebih banyak byte daripada solusi Pyth @ Maltysen. Tapi itu berjalan dalam 8,5 detik pada laptop saya, sedangkan solusi @ Maltysen tidak menghasilkan solusi dalam 20 menit waktu berjalan.

Tetapi masih sedikit terlalu lambat untuk kompiler online.

Penjelasan

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