W komiksie internetowym Darths & Droids Pete, który gra R2-D2 w fikcyjnej kampanii RPG, wokół której opiera się komiks, twierdzi kiedyś (ostrzeżenie: potencjalne spoilery w połączonym komiksie), że wraz z Zagubioną Kulą Phanastacorii przygotował się do jego sonda uderzeniowa, teraz może wydać potężną 1048576d4uszkodzenia. (MG nie potwierdził ani nie zaprzeczył temu.) Ponieważ powinno być dość oczywiste, że prawie nikt nie będzie miał cierpliwości, aby rzucić tyloma kostkami, napisz program komputerowy, który zrobi to za niego, przedstawiając całkowitą wartość wyrzuconą w rozsądnych granicach format. Wpisy zostaną uszeregowane według wielkości programu (najkrótszy program, liczba bajtów, wygrane), zarówno w ujęciu ogólnym, jak i według języka, z przerwami w czasie wykonywania. Odpowiedź może być pełną definicją programu lub funkcji.

Wyniki dla poszczególnych języków

Pyt

Maltysen - 8 bajtów *

Jakube - 10 bajtów

APL

Alex A - 10 bajtów

CJam

Optymalizator - 11 bajtów

jot

--ıʇǝɥʇuʎs - 12 bajtów **

Clip10

Ypnypn - 12 bajtów **

K.

JohnE - 13 bajtów

Ti-84 BASIC

SuperJedi224 - 17 bajtów *

R

MickyT - 23 bajty

OCTAVE / MATLAB

Oebele - 24 bajty

PARI / GP

Charles - 25 bajtów **

Wolfram / Mathematica

LegionMammal978 - 27 bajtów

Perl

Nutki - 29 bajtów

AsciiThenAnsii - 34 bajty

Rubin

Haegin - 32 bajty **

ConfusedMr_C - 51 bajtów **

Commodore Basic

Znak - 37 bajtów **

PHP

Ismael Miguel - 38 bajtów

VBA

Sean Cheshire - 40 bajtów **

PowerShell

Nacht - 41 bajtów **

JavaScript

Ralph Marshall - 41 bajtów

edc65 - 54 bajty (wymaga funkcji ES6 nie jest dostępna we wszystkich przeglądarkach).

Lua

kryptych - 51 bajtów

Jawa

RobAu - 52 bajty **

Geobity - 65 bajtów

do

Functino - 57 bajtów

Pyton

CarpetPython - 58 bajtów

Postgre / SQL

Andrew - 59 bajtów **

Szybki

Skrundz - 69 bajtów

GoatInTheMachine - 81 bajtów

Haskell

Zeta - 73 bajty **

ActionScript

Brian - 75 bajtów **

> <>

ConfusedMr_C - 76 bajtów

UDAĆ SIĘ

Kristoffer Sall-Storgaard - 78 bajtów

DO#

Brandon - 91 bajtów **

Andrew - 105 bajtów

Ewan - 148 bajtów

Zadraśnięcie

SuperJedi224 - 102 bajty

C ++

Michelfrancis Bustillos - 154 bajty

Poligloty

Ismael Miguel (JavaScript / ActionScript2) - 67 bajtów

Top 10 ogólnie

Maltysen
Alex A.
Jakube
Optymalizator
ɐɔıʇǝɥʇuʎs / Ypnypn (niepewne zamówienie)
JohnE
SuperJedi224
MickyT
Oebele

Zaprogramowany oznaczony ** Nie byłem jeszcze w stanie poprawnie przetestować

Pyth - 9 8 bajtów

Wykorzystuje oczywistą prostą metodę sumowania randinta. Uświadomienie sobie , że zajęło mi chwilę, 1048576było 2^20naprawdę głupie. Dzięki @Jakube za uratowanie mi bajtu przez wskazanie 2^20 = 4^10.

smhO4^4T

Środowisko uruchomieniowe jest okropne, jeszcze nie skończyło się na moim komputerze, więc nie ma sensu uruchamiać go online, więc oto 2^10jeden: wypróbuj go tutaj .

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 bajtów

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

Drukuje sumę bez końcowego znaku nowej linii.
Zaoszczędzono 4 bajty, zastępując 2**20(dzięki Maltysen) i usuwając cudzysłowy wokół wydruku.
Zapisałem kolejne 7 bajtów, przestawiając kod (dzięki Thaylon!)
Straciłem 2 bajty, ponieważ mój stary kod wygenerował 0-4 (powinno być 1-4).
Jeszcze raz zaoszczędziłem 5 bajtów dzięki Caek i nutki.

Nieskluczony, poprawnie napisany kod:

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

APL, 11 10 bajtów

+/?4⍴⍨2*20

To po prostu bierze sumę tablicy 2 ²⁰ = 1048576 losowych liczb całkowitych od 1 do 4.

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

Możesz to przetestować na TryAPL , drukując znacznik czasu przed i po. Zajmuje to około 0,02 sekundy.

Zaoszczędzono bajt dzięki marinus i FUZxxl!

Ti-84 Basic, 17 bajtów

Całkowity ślad - Rozmiar nagłówka programu = 17 bajtów

Czas pracy: nieznany, szacowany na 5-6 godzin na podstawie wydajności dla mniejszej liczby rolek (więc w zasadzie niezbyt dobry)

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

R, 32 24 23 21 bajtów

Edycja: Pozbyłem się as.integeri użyłem podziału na liczby całkowite %/%. Przyspiesz nieznacznie.

Dzięki Alex A za końcówkę próbki ... i Giuseppe za usunięcie r=

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

Testowane z

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)

Wyjścia

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

Aby uzyskać czystą prędkość, należy wykonać następujące czynności w mikrosekundach. Jednak nie jestem pewien, czy moja logika jest poprawna. Wyniki wydają się zgodne z metodą losową. Szkoda, że ​​to dłuższa długość.

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

Oto przebieg pomiaru czasu na moim komputerze

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 bajtów

Otrzymujemy 1048576 losowych znaków z systemu operacyjnego, pobieramy po 2 bity i dodajemy. Korzystanie z osbiblioteki pozwala zaoszczędzić kilka znaków przed użyciem randombiblioteki.

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

To zajmuje około 0,2 sekundy na moim komputerze.

CJam, 12 11 bajtów

YK#_{4mr+}*

To jest całkiem proste:

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)

Ale piękno tego polega na tym, że jest też naprawdę szybki! Na moim komputerze (i przy użyciu kompilatora Java ) zajmuje to średnio 70 milisekund.

Wersja online zajmuje około 1,7 sekundy na moim komputerze.

Aktualizacja : 1 bajt zapisany dzięki DocMax

JavaScript (ES6), 54 bajty

Średni czas <100 ms Uruchom fragment kodu, aby przetestować (w przeglądarce 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>

Wyjaśnienie

Bez wbudowanego pakietu statystycznego, w Javascripcie najkrótszym sposobem uzyskania sumy 1 miliona liczb losowych jest milionowe wywołanie random (). Po prostu

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
}

Teraz dodanie 1 miliona razy jest dokładnie takie samo jak dodanie 1 miliona, a nawet lepiej, zacznij sumę od 1 miliona, a następnie dodaj resztę:

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
}

Następnie golf, upuść zmienną temp r i upuść deklarację zmiennych lokalnych. tjest parametrem, ponieważ potrzebny jest do skrócenia deklaracji f. ijest globalny (zła rzecz)

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

Następnie znajdź sposób na uniknięcie „powrotu” za pomocą bezimiennej funkcji wewnętrznej. Jako efekt uboczny uzyskujemy kolejny parametr, więc nie używa się globałów

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

Generuje tabelę o wymaganej długości.

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

J (12 bajtów, około 9,8 milisekund)

+/>:?4$~2^20

Podejrzewam, że jest to głównie ograniczenie przepustowości pamięci: nie mogę nawet zmaksymalizować jednego rdzenia ...

Możesz to przetestować za pomocą następującego kodu:

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

Prowadzi to do 4 grup po 20 tras i zwraca liczbę milisekund średniego czasu w najszybszej grupie. Tłumacz można znaleźć tutaj .

Pyth, 10 bajtów

u+GhO4^4TZ

Ma to nieco więcej bajtów niż rozwiązanie Pyth @ Maltysen. Ale działa na 8,5 sekundy na moim laptopie, podczas gdy rozwiązanie @ Maltysen nie wyprodukowało żadnego rozwiązania w ciągu 20 minut.

Ale wciąż jest trochę za wolny dla kompilatora online.

Wyjaśnienie

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

Skoro mamy wyniki wymienione według języka, dlaczego nie wrzucić Java do miksu? Nie ma tu dużo golfa, tylko prosta pętla, ale udało mi się wycisnąć kilka z mojej pierwszej próby:

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

Matlab, 24

Pierwsze zgłoszenie w historii!

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

Miałem nadzieję, że skorzystam z randi ([1,4], 1024), która daje macierz 1048576 elementów, ale potem potrzebowałem podwójnej sumy, która zajmuje więcej znaków niż to.

Jeśli chodzi o prędkość biegu wspomnianą w pytaniu, timeitmówi mi, że czas działania wynosi około 0,031 sekundy. Tak więc prawie natychmiast.

Haskell, 73 bajty

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

Stosowanie:

$ ghci sourcefile.hs
ghci> f
2622130

C #: 105 bajtów

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 bajtów

Wykorzystuje to bardzo prosty pomysł: zsumuj je wszystkie!

Zauważyłem też, że 1048576jest to 10000000000000000000binarny odpowiednik 1<<20.

Oto kod:

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

Przetestuj w przeglądarce (z bardzo małymi zmianami):

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

Wszystkie zmiany w kodzie są wyjaśnione w komentarzach.

Mathematica, 30 27 bajtów

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

Mathematica ma dość długie nazwy funkcji ...

C, 57 bajtów

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

Ten kod działa ... raz. Jeśli kiedykolwiek trzeba ponownie toczyć te kości, musisz umieścić srand(time(0))tam, dodając 14 bajtów.

PostgreSQL, 59 bajtów

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

Przyznaję się do drobnego problemu, random()który teoretycznie mógłby dać dokładnie zero, w którym to przypadku rzut matrycy wynosiłby zero.

Rubinowy, 32 bajty

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

W bardziej czytelnej formie:

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

Tworzy zakres od 1 do 1048576, a następnie tyle razy iteruje blok. Za każdym razem, gdy blok jest wykonywany, wartość z poprzedniej iteracji jest przekazywana jako x(początkowo 0, domyślnie dlainject ). Każda iteracja oblicza liczbę losową od 0 do 3 (włącznie), dodaje jedną, symulując rzut d4 i dodaje ją do sumy.

Na moim komputerze jest dość szybki do uruchomienia (0.25 real, 0.22 user, 0.02 sys ).

Jeśli masz zainstalowany Ruby, możesz go uruchomić z ruby -e 'p (1..2**20).inject{|x|x+rand(4)+1}'(p konieczne jest, aby zobaczyć wynik, gdy jest uruchamiany w ten sposób, pomiń go, jeśli cię to nie obchodzi, lub po prostu uruchom go w IRB, gdzie wynik jest drukowany na ekranie dla Ciebie). Przetestowałem to na Ruby 2.1.6.

Dzięki histocrat dla bitowym twiddling hack, który zastępuje x + rand(4) + 1z x-~rand(4).

PARI / GP, 25 bajtów

Naprawdę nie ma tu potrzeby gry w golfa - jest to prosty sposób na wykonanie obliczeń w GP. Działa na mojej maszynie w 90 milisekund. Podnoszenie +1oszczędza około 20 milisekund.

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

Dla zabawy: jeśli ktoś optymalizuje wydajność w 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;
}

ma bardzo małą całkowitą liczbę operacji - jeśli xorgens potrzebuje ~ 27 cykli na 64-bitowe słowo (czy ktoś może to zweryfikować?), to procesor z POPCNT powinien zająć tylko około 0,5 cyklu / bit, lub kilkaset mikrosekund do końcowego numer.

Powinno to mieć prawie optymalną wydajność w najgorszym przypadku wśród metod wykorzystujących losowe liczby o podobnej lub wyższej jakości. Powinno być możliwe znaczne zwiększenie średniej prędkości poprzez łączenie przypadków - może milion rolek na raz - i wybieranie z (zasadniczo) kodowaniem arytmetycznym .

JavaScript, 55 53 50 47 41 bajtów

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

Nie zdawałem sobie sprawy, że liczby nieprzypadkowe są znanym czynnikiem drażniącym, więc sądzę, że powinienem opublikować prawdziwe rozwiązanie. Oznacza brak szacunku.

Komentarz: jak zauważyli inni powyżej, możesz pominąć +1 do każdego rzutu, zaczynając od liczby rzutów w swojej odpowiedzi i nie musząc pisać a = 0, i = 1 << 20 oszczędzasz dwa bajty, i kolejne 2, ponieważ nie dodajesz +1 do każdego rzutu. Funkcja parseInt działa tak samo jak Math.floor, ale ma 2 znaki krótsze.

Klip 10 , 12 bajtów

r+`m[)r4}#WT

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

Uruchomienie mojego komputera zajmuje około 0,6 sekundy.

Idź, 78 bajtów

Grał w golfa

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

Nadal nad tym pracuję

Uruchom online tutaj http://play.golang.org/p/pCliUpu9Eq

Idź, 87 bajtów

Naiwne rozwiązanie

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

Uruchom online tutaj: http://play.golang.org/p/gwP5Os7_Sq

Ze względu na sposób działania placu zabaw Go musisz ręcznie zmienić ziarno (czas jest zawsze taki sam)

Commodore Basic, 37 bajtów

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

Podstawienia PETSCII: ─= SHIFT+E, /= SHIFT+N, ┌=SHIFT+O

Szacowany czas działania na podstawie przebiegów z mniejszą liczbą kości: 4,25 godziny.

Kusząca jest próba odłożenia dwóch bajtów w golfa, tworząc Cliczbę całkowitą i domyślnie zaokrąglając liczby losowe. Jednak zakres liczb całkowitych w Commodore Basic wynosi od -32678 do 32767 - to za mało, gdy mediana odpowiedzi wynosi 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();}