웹 코믹에서 Darths & 드로 이드 가상 롤 플레잉 캠페인에서 R2-D2를 재생, 피트, 이는 주변의 만화는, 기반 주장 번 : Phanastacoria의 잃어버린 오브와 (경고 링크 된 만화의 잠재적 스포일러) 즉, 최대 리깅 자신의 충격 프로브, 그는 이제 무려 1048576d4손상. (GM은 이것을 확인하거나 거부하지 않았다.) 거의 아무도 그 많은 주사위를 굴릴 인내심을 가지고 있지 않다는 것이 명백히 분명하기 때문에, 그것을 위해 그것을 할 수있는 컴퓨터 프로그램을 작성하여 합당한 총 가치를 산출한다. 체재. 항목은 전체 및 언어별로 프로그램 크기 (가장 짧은 프로그램, 바이트 수, 승리)별로 순위가 매겨지며 런타임 속보가 결정됩니다. 답은 완전한 프로그램이거나 함수 정의 일 수 있습니다.

언어 별 점수

피스

말 티센-8 바이트 *

자쿠 베-10 bytes

APL

Alex A-10 바이트

CJam

옵티 마이저-11 바이트

J

ɐɔıʇǝɥʇuʎs-12 바이트 **

클립 10

Ypnypn-12 바이트 **

케이

JohnE-13 바이트

Ti-84 기본

SuperJedi224-17 바이트 *

아르 자형

MickyT-23 바이트

옥타브 / 매트랩

오 벨레-24 바이트

파리 / GP

찰스-25 바이트 **

볼프람 / 수학

LegionMammal978-27 바이트

펄

Nutki-29 바이트

AsciiThenAnsii-34 바이트

루비

해긴-32 바이트 **

ConfusedMr_C-51 바이트 **

코모도 베이직

마크-37 바이트 **

PHP

이스마엘 미겔-38 바이트

VBA

Sean Cheshire-40 바이트 **

PowerShell

Nacht-41 바이트 **

자바 스크립트

랄프 마샬-41 바이트

edc65-54 바이트 (모든 브라우저에서 ES6 기능을 사용할 수있는 것은 아님)

루아

cryptych-51 바이트

자바

RobAu-52 바이트 **

지오 비트-65 바이트

기음

펑 티노-57 바이트

파이썬

CarpetPython-58 바이트

Postgre / SQL

Andrew-59 바이트 **

빠른

Skrundz-69 바이트

GoatInTheMachine-81 바이트

하스켈

제타-73 바이트 **

액션 스크립트

브라이언-75 바이트 **

> <>

ConfusedMr_C-76 바이트

가기

Kristoffer Sall-Storgaard-78 바이트

기음#

브랜든-91 바이트 **

Andrew-105 바이트

이완-148 바이트

할퀴다

SuperJedi224-102 바이트

C ++

Michelfrancis Bustillos-154 바이트

폴리 글 로트

Ismael Miguel (Javascript / ActionScript2)-67 바이트

전체 톱 10

말 티센
알렉스 A
자쿠 베
옵티 마이저
ɐɔıʇǝɥʇuʎs / Ypnypn (주문 불확실)
존
슈퍼 제다이 224
미 키티
오 벨레

프로그램 표시 ** 아직 제대로 테스트 할 수 없습니다

Pyth- 9 8 바이트

randint의 명백한 간단한 합계 방법을 사용합니다. 실현에 나에게 분 걸렸 1048576습니다2^20 되었으므로 이제는 정말 바보 같은 느낌이 들었습니다. 지적하여 바이트를 절약 해 주신 @Jakube에게 감사드립니다 2^20 = 4^10.

smhO4^4T

런타임은 끔찍합니다. 아직 컴퓨터에서 끝나지 않았으므로 온라인으로 실행할 시점이 없으므로 여기에 2^10 하나는 온라인 여기를보십시오 .

s        Summation
 m       Map
  h      Incr (accounts for 0-indexed randint)
   O4    Randint 4
  ^4T    Four raised to ten

펄 -48 44 37 39 34 바이트

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

후행 줄 바꿈없이 합계를 인쇄합니다. (Maltysen에게 감사)
를 대신 2**20하고 인쇄 주위의 따옴표를 제거하여 4 바이트를 절약했습니다 .
코드를 다시 정렬하여 7 바이트를 더 절약했습니다 (Taylon 덕분에!)
이전 코드에서 0-4를 생성했기 때문에 2 바이트를 잃었습니다 (1-4 여야 함).
다시 한번, Caek과 nutki 덕분에 5 바이트를 절약했습니다.

제대로 작성되지 않은 코드 :

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

APL, 11 10 바이트

+/?4⍴⍨2*20

이것은 1과 4 사이 의 2 ²⁰ = 1048576 임의의 정수 의 배열의 합을 취합니다 .

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

당신은 할 수 있습니다 이전과 이후의 타임 스탬프를 인쇄하여 TryAPL에서이를 벤치 마크 . 약 0.02 초가 소요됩니다.

marinus와 FUZxxl 덕분에 바이트를 절약했습니다!

Ti-84 기본, 17 바이트

총 설치 공간-프로그램 헤더 크기 = 17 바이트

실행 시간 : 알 수 없음, 5-6 시간으로 추정 적은 수의 롤 성능에 따라 으로 (기본적으로 매우 좋지 않음)

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

R, 32 24 23 21 바이트

편집 : as.integer및 정수 나누기를 제거했습니다 %/%. 약간 속도를 높이십시오.

샘플 팁을위한 Alex A와 ... r=

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

테스트

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)

출력

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

순수한 속도를 위해 마이크로 초 단위로 다음이 완료됩니다. 그러나 논리가 올바른지 잘 모르겠습니다. 결과는 임의의 방법과 일치하는 것으로 보입니다. 길이가 더 길 다니

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

내 컴퓨터에서 수행 한 타이밍 실행은 다음과 같습니다.

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

We get 1048576 random characters from the operating system, take 2 bits of each, and add them up. Using the os library seems to save a few characters over using the random library.

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

This takes about 0.2 seconds on my PC.

CJam, 12 11 bytes

YK#_{4mr+}*

This is pretty straight foward:

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)

But the beauty of this is that its really fast too! On my machine (and using the Java compiler) it takes on an average of 70 milliseconds.

The online version takes around 1.7 seconds on my machine.

Update: 1 byte saved thanks to DocMax

JavaScript (ES6), 54 bytes

Average time < 100 msec. Run snippet to test (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>

Explanation

With no statistical package built-in, in Javascript the shortest way to obtain the sum of 1 million random number is to call random() for a million times. So simply

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
}

Now, adding 1 for a million times is exactly the same than adding 1 million, or even better, start the sum with 1 million and then add the rest:

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
}

Then golf, drop the temp variable r and drop the declaration of local variables. t is a parameter, as one is needed to shorten the declaration of f. i is global (bad thing)

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

Then find a way to avoid 'return' using a nameless inner function. As a side effect, we gain another parameter so no globals used

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

Generates a table of the required length.

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

J (12 bytes, about 9.8 milliseconds)

+/>:?4$~2^20

I suspect this is mostly memory bandwith-limited: I can't even get it to max out a single core...

You can test this with the following code:

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

This runs it in 4 groups of 20 trails, and returns the number of milliseconds of the avarage time in the quickest group. An interpreter can be found here.

Pyth, 10 bytes

u+GhO4^4TZ

This has slightly more bytes than @Maltysen's Pyth solution. But it runs in 8.5 seconds on my laptop, while @Maltysen's solution produced no solution in 20 minutes running time.

But still a little bit too slow for the online compiler.

Explanation

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