ในคอมมิคDarths & Droids , Pete ผู้เล่น R2-D2 ในแคมเปญสวมบทบาทสวมบทบาทที่การ์ตูนมีพื้นฐานมาจากการอ้างสิทธิ์ครั้งเดียว (คำเตือน: สปอยเลอร์ที่มีศักยภาพในการ์ตูนที่เชื่อมโยง) ซึ่งกับ Orb แห่ง Phanastacoria โพรบช็อตตอนนี้เขาสามารถกำจัด 1048576d4มหันต์ของความเสียหาย (จีเอ็มไม่ได้ยืนยันหรือปฏิเสธสิ่งนี้) เนื่องจากมันควรจะมีเหตุผลที่ชัดเจนว่าแทบจะไม่มีใครมีความอดทนที่จะม้วนลูกเต๋าหลาย ๆ อันให้เขียนโปรแกรมคอมพิวเตอร์เพื่อทำเพื่อเขา รูปแบบ. รายการจะถูกจัดอันดับตามขนาดของโปรแกรม (โปรแกรมที่สั้นที่สุดตามจำนวนไบต์ชนะ) ทั้งโดยรวมและต่อภาษาโดยมีความสัมพันธ์แบบแบ่งเวลา คำตอบอาจเป็นได้ทั้งโปรแกรมเต็มรูปแบบหรือฟังก์ชั่นการกำหนด

คะแนนต่อภาษา

Pyth

Maltysen - 8 ไบต์ *

Jakube - 10 ไบต์

APL

Alex A - 10 ไบต์

CJam

เครื่องมือเพิ่มประสิทธิภาพ - 11 ไบต์

J

--ıʇǝɥʇuʎs - 12 ไบต์ **

Clip10

Ypnypn - 12 ไบต์ **

K

JohnE - 13 ไบต์

Ti-84 พื้นฐาน

SuperJedi224 - 17 ไบต์ *

R

MickyT - 23 ไบต์

Octave / MATLAB

Oebele - 24 ไบต์

PARI / GP

Charles - 25 ไบต์ **

วุลแฟรม / มาติกา

LegionMammal978 - 27 ไบต์

Perl

Nutki - 29 ไบต์

AsciiThenAnsii - 34 ไบต์

ทับทิม

Haegin - 32 ไบต์ **

ConfusedMr_C - 51 ไบต์ **

พลเรือจัตวาพื้นฐาน

มาร์ค - 37 ไบต์ **

PHP

Ismael Miguel - 38 ไบต์

VBA

Sean Cheshire - 40 ไบต์ **

PowerShell

Nacht - 41 ไบต์ **

จาวาสคริ

Ralph Marshall - 41 ไบต์

edc65 - 54 ไบต์ (ต้องการฟังก์ชั่น ES6 ที่ไม่มีในเบราว์เซอร์ทั้งหมด)

Lua

cryptych - 51 ไบต์

ชวา

RobAu - 52 ไบต์ **

Geobits - 65 ไบต์

ค

Functino - 57 ไบต์

หลาม

CarpetPython - 58 ไบต์

Postgre / SQL

Andrew - 59 ไบต์ **

รวดเร็ว

Skrundz - 69 ไบต์

GoatInTheMachine - 81 ไบต์

Haskell

Zeta - 73 ไบต์ **

ActionScript

Brian - 75 ไบต์ **

> <>

ConfusedMr_C - 76 ไบต์

ไป

Kristoffer Sall-Storgaard - 78 ไบต์

ค#

แบรนดอน - 91 ไบต์ **

Andrew - 105 ไบต์

Ewan - 148 ไบต์

เกา

SuperJedi224 - 102 ไบต์

C ++

Michelfrancis Bustillos - 154 ไบต์

polyglots

Ismael Miguel (Javascript / ActionScript2) - 67 ไบต์

โดยรวม 10 อันดับแรก

Maltysen
อเล็กซ์
Jakube
เพิ่มประสิทธิภาพ
ɐɔıʇǝɥʇuʎs / Ypnypn (ความไม่แน่นอนของคำสั่งซื้อ)
Johne
SuperJedi224
MickyT
Oebele

ทำเครื่องหมายเป็นโปรแกรม ** ฉันยังไม่สามารถทดสอบได้อย่างถูกต้อง

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

Perl - 48 44 37 39 34 ไบต์

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

พิมพ์ผลรวมโดยไม่ขึ้นบรรทัดใหม่
บันทึก 4 ไบต์ด้วยการแทนที่2**20(ขอบคุณ Maltysen) และลบเครื่องหมายคำพูดรอบ ๆ การพิมพ์
บันทึกอีก 7 ไบต์ด้วยการจัดเรียงโค้ดใหม่ (ขอบคุณ Thaylon!)
เสีย 2 ไบต์เนื่องจากรหัสเก่าของฉันสร้างขึ้น 0-4 (ควรเป็น 1-4)
บันทึกอีก 5 ไบต์ด้วย Caek และ nutki

โค้ดที่เขียนผิดอย่างถูกต้อง:

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

APL, 11 10 ไบต์

+/?4⍴⍨2*20

นี่จะใช้ผลรวมของอาร์เรย์ของ 2 ²⁰ = 1048576 จำนวนเต็มแบบสุ่มระหว่าง 1 และ 4

+/           ⍝ 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 ไบต์

Total footprint - ขนาดของส่วนหัวของโปรแกรม = 17 ไบต์

เวลาทำงาน: ไม่รู้จักประมาณ 5-6 ชั่วโมงขึ้นอยู่กับประสิทธิภาพของม้วนน้อย (โดยทั่วไปไม่ดีมาก)

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

R, 32 24 23 21 ไบต์

แก้ไข: Got กำจัดของใช้ส่วนจำนวนเต็มas.integer %/%เร่งความเร็วขึ้นเล็กน้อย

ขอบคุณ Alex A สำหรับเคล็ดลับตัวอย่าง ... และ Giuseppe สำหรับการลบ 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 ไบต์

เราได้รับ 1048576 ตัวอักษรแบบสุ่มจากระบบปฏิบัติการใช้เวลา 2 บิตของแต่ละตัวและเพิ่มขึ้น การใช้osไลบรารีดูเหมือนจะบันทึกอักขระสองสามตัวโดยใช้randomห้องสมุด

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

ใช้เวลาประมาณ 0.2 วินาทีในพีซีของฉัน

CJam, 12 11 ไบต์

YK#_{4mr+}*

นี่มันช่างตรงไปตรงมา:

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)

แต่ความงามของมันก็คือมันเร็วเกินไป! บนเครื่องของฉัน (และใช้คอมไพเลอร์ Java ) ใช้เวลาเฉลี่ย 70 มิลลิวินาที

รุ่นออนไลน์ใช้เวลาประมาณ 1.7 วินาทีในเครื่องของฉัน

อัปเดต : บันทึก 1 ไบต์ด้วย DocMax

JavaScript (ES6), 54 ไบต์

เวลาเฉลี่ย <100 msec เรียกใช้ตัวอย่างเพื่อทดสอบ (ใน 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>

คำอธิบาย

ไม่มีแพคเกจสถิติในตัวใน Javascript วิธีที่สั้นที่สุดในการรับผลรวมของตัวเลขสุ่ม 1 ล้านคือการโทรสุ่ม () เป็นล้านครั้ง ดังนั้นง่ายๆ

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
}

ทีนี้การเพิ่ม 1 สำหรับล้านครั้งก็เหมือนกับการเพิ่ม 1 ล้านหรือดีกว่าเริ่มรวมกับ 1 ล้านแล้วเพิ่มส่วนที่เหลือ:

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
}

จากนั้นกอล์ฟวางตัวแปร temp r และวางการประกาศตัวแปรท้องถิ่น เป็นพารามิเตอร์ที่เป็นหนึ่งเป็นสิ่งจำเป็นที่จะลดลงประกาศของt เป็นสากล (สิ่งเลวร้าย)fi

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

จากนั้นหาวิธีหลีกเลี่ยง 'การกลับมา' โดยใช้ฟังก์ชั่นภายในแบบไม่ระบุชื่อ ในฐานะที่เป็นผลข้างเคียงเราได้รับพารามิเตอร์อื่นดังนั้นจึงไม่ได้ใช้รูปทรงกลม

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

สร้างตารางที่มีความยาวที่ต้องการ

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

J (12 ไบต์, ประมาณ 9.8 มิลลิวินาที)

+/>:?4$~2^20

ฉันสงสัยว่านี่เป็นหน่วยความจำแบนด์วิดท์ที่มี จำกัด ส่วนใหญ่: ฉันไม่สามารถแม้แต่จะทำให้มันเป็นแกนหลักเดียว ...

คุณสามารถทดสอบสิ่งนี้ด้วยรหัสต่อไปนี้:

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

สิ่งนี้รันในกลุ่ม 4 กลุ่มจาก 20 เส้นทางและส่งคืนจำนวนมิลลิวินาทีของเวลาความเสียหายในกลุ่มที่เร็วที่สุด ล่ามสามารถพบได้ที่นี่

Pyth, 10 ไบต์

u+GhO4^4TZ

นี่มีไบต์มากกว่าโซลูชัน Pyth ของ @ Maltysen เล็กน้อย แต่มันใช้งานได้ใน 8.5 วินาทีบนแล็ปท็อปของฉันในขณะที่โซลูชันของ @ Maltysen ไม่สามารถแก้ปัญหาได้ในเวลา 20 นาที

แต่ก็ยังช้าไปหน่อยสำหรับคอมไพเลอร์ออนไลน์

คำอธิบาย

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

เนื่องจากเรามีคะแนนตามภาษาทำไมไม่โยน Java ลงในส่วนผสม? ที่นี่มีกอล์ฟไม่มากนักแค่วนซ้ำง่าย ๆ แต่ฉันสามารถบีบความพยายามครั้งแรกของฉันออกเป็นสอง:

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

Matlab, 24

ส่งครั้งแรก!

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

ฉันหวังว่าจะใช้ประโยชน์จาก randi ([1,4], 1024) ซึ่งให้เมทริกซ์ขององค์ประกอบ 1048576 แต่จากนั้นฉันต้องการผลรวมสองเท่าซึ่งใช้อักขระมากกว่านี้

เกี่ยวกับความเร็วในการวิ่งที่กล่าวถึงในคำถาม timeitบอกฉันว่ารันไทม์ประมาณ 0.031 วินาที ดังนั้นทันใดนั้นเอง

Haskell, 73 ไบต์

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

การใช้งาน:

$ ghci sourcefile.hs
ghci> f
2622130

C #: 105 ไบต์

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 ไบต์

สิ่งนี้ใช้ความคิดที่ง่ายมาก: รวมพวกมันทั้งหมด!

นอกจากนี้ผมได้สังเกตเห็นว่า1048576เป็นในไบนารีเทียบเท่ากับ100000000000000000001<<20

นี่คือรหัส:

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

ทดสอบในเบราว์เซอร์ของคุณ (ด้วยการเปลี่ยนแปลงVERY LITTLE ):

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

การเปลี่ยนแปลงทั้งหมดในรหัสได้อธิบายไว้ในความคิดเห็น

Mathematica, 30 27 ไบต์

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

Mathematica มีชื่อฟังก์ชั่นค่อนข้างยาว ...

C, 57 ไบต์

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

รหัสนี้ใช้งานได้ ... ครั้งเดียว หากคุณจำเป็นต้องหมุนลูกเต๋าเหล่านั้นอีกครั้งคุณจะต้องใส่srand(time(0))เข้าไปที่นั่นเพิ่มขึ้น 14 ไบต์

PostgreSQL ขนาด 59 ไบต์

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

ฉันจะยอมรับกับปัญหาเล็กน้อยที่random()ในทางทฤษฎีแล้วสามารถสร้างศูนย์ได้อย่างแน่นอนซึ่งในกรณีนี้การหมุนตายจะเป็นศูนย์

Ruby, 32 ไบต์

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

ในรูปแบบที่อ่านได้มากขึ้น:

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

มันสร้างช่วงจาก 1 ถึง 1048576 แล้ววนซ้ำบล็อกนั้นหลาย ๆ ครั้ง ทุกครั้งที่มีการดำเนินการบล็อกค่าจากการทำซ้ำก่อนหน้านี้จะถูกส่งผ่านเป็นx(เริ่มต้น 0, เริ่มต้นสำหรับinject) การวนซ้ำแต่ละครั้งจะคำนวณตัวเลขสุ่มระหว่าง 0 ถึง 3 (รวม) เพิ่มหนึ่งค่าดังนั้นจึงจำลองการหมุน d4 และเพิ่มเข้ากับยอดรวม

บนเครื่องของฉันมันค่อนข้างเร็วในการรัน ( 0.25 real, 0.22 user, 0.02 sys)

หากคุณติดตั้ง Ruby คุณสามารถเปิดใช้งานด้วยruby -e 'p (1..2**20).inject{|x|x+rand(4)+1}'(pจำเป็นต้องเห็นผลลัพธ์เมื่อทำงานในลักษณะนี้ให้ละเว้นหากคุณไม่สนใจหรือเรียกใช้ภายใน IRB ซึ่งพิมพ์ผลลัพธ์ไปที่หน้าจอ สำหรับคุณ). ฉันได้ทำการทดสอบกับ Ruby 2.1.6 แล้ว

ขอขอบคุณที่ histocrat สำหรับบิต twiddling สับที่มาแทนที่ด้วยx + rand(4) + 1x-~rand(4)

PARI/GP, 25 bytes

จริงๆไม่จำเป็นต้องเล่นกอล์ฟที่นี่ - นี่เป็นวิธีการคำนวณที่ตรงไปตรงมาใน GP มันทำงานใน 90 มิลลิวินาทีบนเครื่องของฉัน การชักรอก+1จะช่วยประหยัดประมาณ 20 มิลลิวินาที

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

เพียงเพื่อความสนุกสนานถ้าใครได้รับการเพิ่มประสิทธิภาพสำหรับผลการดำเนินงานใน 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;
}

มีจำนวนการดำเนินการโดยรวมที่น้อยมาก - ถ้าxorgensต้องการ ~ 27 รอบต่อคำที่ 64 บิต (ใครสามารถตรวจสอบได้?) ดังนั้นโปรเซสเซอร์ที่มี POPCNT ควรใช้เวลาประมาณ 0.5 รอบ / บิตหรือไม่กี่ร้อยไมโครวินาทีในขั้นสุดท้าย จำนวน.

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