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

Оцінки за мову

Піт

Мальтісен - 8 байт *

Якубе - 10 байт

APL

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

CJam

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

J

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

Кліп10

Ypnypn - 12 байт **

К

JohnE - 13 байт

Ti-84 BASIC

SuperJedi224 - 17 байт *

R

MickyT - 23 байти

OCTAVE / MATLAB

Oebele - 24 байти

PARI / GP

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

Вольфрам / Математика

LegionMammal978 - 27 байт

Perl

Нутки - 29 байт

AsciiThenAnsii - 34 байти

Рубін

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

ConfusedMr_C - 51 байт **

Commodore Basic

Позначити - 37 байт **

PHP

Ісмаїл Мігель - 38 байт

VBA

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

PowerShell

Нахт - 41 байт **

Javascript

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

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

Луа

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

Java

RobAu - 52 байти **

Геобіт - 65 байт

С

Функтино - 57 байт

Пітон

CarpetPython - 58 байт

Postgre / SQL

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

Швидкий

Skrundz - 69 байт

GoatInTheMachine - 81 байт

Хаскелл

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

ActionScript

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

> <>

ConfusedMr_C - 76 байт

ПОВЕРНУТИСЯ

Kristoffer Sall-Storgaard - 78 байт

C #

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

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

Еван - 148 байт

Скретч

SuperJedi224 - 102 байти

C ++

Michelfrancis Bustillos - 154 байти

Поліглоти

Ісмаїл Мігель (Javascript / ActionScript2) - 67 байт

Топ-10 в цілому

Малтісен
Олексій А
Якубе
Оптимізатор
ɐɔıʇǝɥʇuʎs / Ypnypn (порядок невизначений)
JohnE
SuperJedi224
МікіТі
Оебеле

Програмований з позначкою ** Я ще не зміг належним чином перевірити

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(спасибі Малтісен) та видаливши лапки навколо друку.
Збережено ще 7 байт шляхом перестановки коду (дякую Тайлону!)
Втрачено 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), A, 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 мільйон випадкових чисел - викликати випадковий () мільйон разів. Так просто

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є параметром, який потрібен для скорочення декларації 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

Перл, 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 @ Малтісена. Але він працює на моєму ноутбуці за 8,5 секунди, тоді як рішення @ Мальтісен не дало рішення за 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;}

Матлаб, 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це 10000000000000000000в бінарному еквіваленті 1<<20.

Ось код:

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

Перевірте у своєму браузері (З ДУЖЕ МАЛИМИ змін):

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

Усі зміни коду пояснюються в коментарях.

Математика, 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()теоретично могла б створити рівно нуль, і в цьому випадку валик для матриці був би нульовим.

Рубін, 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 для операцій з бітами хака , який замінює x + rand(4) + 1з x-~rand(4).

PARI / GP, 25 байт

Дійсно, тут немає необхідності в гольфі - це прямий спосіб розрахунку в 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 циклу / біт або кілька сотень мікросекунд для остаточного число.

Це повинно мати близькі до оптимальних показники в гіршому випадку серед методів, що використовують випадкові числа аналогічної або вищої якості. Повинно бути можливим значно збільшити середню швидкість, комбінуючи випадки - можливо, мільйон рулонів одночасно - і вибираючи (по суті) арифметичне кодування .

Javascript, 55 53 50 47 41 байт

for(a=i=1<<20;i--;)a+=(Math.random()*4)|0

Я не усвідомлював, що випадкові числа - це відомий подразник, тому я вважаю, що мені слід опублікувати реальне рішення. Не означає неповаги.

Коментар: як зазначають інші вище, ви можете пропустити +1 до кожного рулону, починаючи з кількості валиків у вашій відповіді, і не потрібно писати а = 0, i = 1 << 20, ви зберігаєте два байти, і ще 2, оскільки ви не додаєте +1 до кожного рулону. Функція parseInt робить те саме, що і Math.floor, але на 2 символи коротше.

Кліп 10 , 12 байт

r+`m[)r4}#WT

         #4T    .- 4^10 = 1048576             -.
   m[   }       .- that many...               -.
     )r4        .-          ...random numbers -.
r+`             .- sum                        -.

На моїй машині потрібно приблизно 0,6 секунди.

Ідіть, 78 байт

Гольф

import."math/rand";func r()(o int){for i:=2<<19;i>=0;i--{o+=Intn(4)+1};return}

Ще над цим працюю

Запустити онлайн тут http://play.golang.org/p/pCliUpu9Eq

Ідіть, 87 байт

Наївне рішення

import"math/rand";func r(){o,n:=0,2<<19;for i:=0;i<n;i++{o+=rand.Intn(4)};println(o+n)}

Запустити онлайн тут: http://play.golang.org/p/gwP5Os7_Sq

Завдяки тому, як працює майданчик Go, вам доведеться вручну міняти насіння (час завжди однаковий)

Commodore Basic, 37 байт

1F┌I=1TO2↑20:C=C+INT(R/(1)*4+1):N─:?C

PETSCII підстановки: ─= SHIFT+E, /=SHIFT+N , ┌=SHIFT+O

Орієнтовна тривалість виконання на основі пробігу з меншою кількістю кісток: 4,25 години.

Заманливо намагатися розіграти два байти, зробивши Cціле число, отримуючи неявне округлення випадкових чисел. Однак діапазон цілих чисел у Commodore Basic становить від -32678 до 32767 - недостатньо, коли середня відповідь - 2621440.

PowerShell, 41 37 байт

1..1mb|%{(get-random)%4+1}|measure -s

Взяв мою машину 2 хвилини 40 секунд

Рубі, 51 47 чол

x=[];(2**20).times{x<<rand(4)+1};p x.inject(:+)

Я переглянув усі відповіді, перш ніж це зробив, і sum(2**20 times {randInt(4)})стратегія справді витримала, тому я використала це.

> <>, 76 символів

012a*&>2*&1v
|.!33&^?&:-<
3.v < >-:v >
   vxv1v^<;3
  1234    n+
  >>>> >?!^^

Я не впевнений, чи працює цей, тому що мій браузер вийшов з ладу, коли я намагався його перевірити, але ось онлайн-перекладач.

Свіфт, 64 байти

Нічого розумного, гольф у Свіфт важко ...

func r()->Int{var x=0;for _ in 0..<(2<<19) {x+=Int(arc4random()%4)+1;};return x;}

Версія 2 (занадто пізно)

var x=0;for _ in 0..<(2<<19){x+=Int(arc4random()%4)+1;};print(x)

Ява (Java 8) - 52

int f(){return new Random().ints(1<<20,1,5).sum();}