В веб-комиксе Darths & Droids Пит, который играет R2-D2 в вымышленной ролевой кампании, на которой основан комикс, однажды заявляет (предупреждение: потенциальные спойлеры в связанном комиксе), что с Потерянным Сферой Фанастакории, подключенной к его ударный зонд, он теперь может выложить колоссальный 1048576d4ущерба. (ГМ не подтвердил и не опроверг это.) Поскольку должно быть достаточно очевидно, что на самом деле почти ни у кого не хватит терпения бросить столько костей, напишите компьютерную программу, которая сделает это для него, и выведите общее значение, выброшенное в разумных пределах. формат. Записи будут ранжироваться по размеру программы (самая короткая программа, по количеству байтов, выигрышам), как по общему, так и по языку, с разрывом связей во время выполнения. Ответом может быть либо полная программа, либо определение функции.

Баллы за язык

Pyth

Maltysen - 8 байт *

Якубе - 10 байт

APL

Алекс А - 10 байт

CJam

Оптимизатор - 11 байт

J

ɐɔıʇǝɥʇuʎs - 12 байт **

Clip10

Ypnypn - 12 байт **

К

JohnE - 13 байт

Ti-84 BASIC

SuperJedi224 - 17 байт *

р

MickyT - 23 байта

OCTAVE / MATLAB

Oebele - 24 байта

PARI / GP

Чарльз - 25 байт **

Вольфрам / Mathematica

LegionMammal978 - 27 байт

Perl

Нутки - 29 байт

AsciiThenAnsii - 34 байта

Рубин

Хаегин - 32 байта **

ConfusedMr_C - 51 байт **

Коммодор Базовый

Марк - 37 байт **

PHP

Исмаэль Мигель - 38 байт

VBA

Шон Чешир - 40 байт **

PowerShell

Nacht - 41 байт **

Javascript

Ральф Маршалл - 41 байт

edc65 - 54 байта (требуется функция ES6, доступная не во всех браузерах.)

Lua

криптих - 51 байт

Джава

RobAu - 52 байта **

Geobits - 65 байт

С

Functino - 57 байт

питон

CarpetPython - 58 байт

Postgre / SQL

Андрей - 59 байт **

стриж

Скрундз - 69 байт

GoatInTheMachine - 81 байт

Haskell

Зета - 73 байта **

ActionScript

Брайан - 75 байт **

> <>

ConfusedMr_C - 76 байт

ИДТИ

Кристоффер Салл-Сторгард - 78 байтов

C #

Брэндон - 91 байт **

Андрей - 105 байт

Эван - 148 байт

царапать

SuperJedi224 - 102 байта

C ++

Мишельфрансис Бустильос - 154 байта

полиглотов

Исмаэль Мигель (Javascript / ActionScript2) - 67 байт

Топ 10 в целом

Maltysen
Алекс А
Jakube
оптимизатор
/ıʇǝɥʇuʎs / Ypnypn (порядок неопределен)
Johne
SuperJedi224
MickyT
Oebele

Запрограммирован отмечен ** Я еще не смог правильно проверить

Pyth - 9 8 байт

Использует очевидный простой метод суммирования рандов. Взял меня минуту , чтобы понять 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 Basic, 17 байтов

Общая площадь - размер заголовка программы = 17 байт

Время выполнения: неизвестно, оценивается в 5-6 часов на основе производительности при меньшем количестве бросков (поэтому, в основном, не очень хорошо)

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

R, 32 24 23 21 байт

Редактировать: Избавился от as.integerи использовал целочисленное деление %/%. Ускорьте это немного.

Спасибо Алексу А за образец подсказки ... и Джузеппе за удаление 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 мсек. Запустите сниппет для проверки (в 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 миллион случайных чисел - это вызвать random () миллион раз. Так просто

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
}

Затем гольф, отбросьте временную переменную r и отбросьте объявление локальных переменных. tявляется параметром, так как он необходим для сокращения объявления f. iглобально (плохо)

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 

Ява, 65

Поскольку у нас есть оценки, перечисленные по языку, почему бы не добавить Java в микс? Здесь не так много для гольфа, просто простая петля, но я смог выжать пару из моей первоначальной попытки:

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