Çizgi romanın dayandığı kurgusal rol yapma kampanyasında R2-D2 oynayan webcomic Darths & Droids'de Pete, bir keresinde , Phanastacoria'nın Kayıp Küresi ile birlikte, Şok probu, şimdi bir okkalı 1048576d4hasar. (GM bunu teyit etmedi veya reddetmedi.) Neredeyse hiç kimsenin o kadar zar atma sabrına sahip olacağı makul bir şekilde açık olacağından, kendisi için bir bilgisayar programı yazarak, makul bir şekilde yuvarlanan toplam değeri çıktılayın biçim. Girişler, program süresi (en kısa program, bayt sayısı, kazanç), hem genel hem de dil başına, çalışma süresi kopma bağlarına göre sıralanacaktır. Yanıt, tam bir program veya bir işlev tanımı olabilir.

Dil Başına Puan

Pyth

Maltysen - 8 bayt *

Jakube - 10 bayt

APL

Alex A - 10 bayt

CJam

Optimize Edici - 11 bayt

J

--ıʇǝɥʇuʎs - 12 bayt **

Clip10

Ypnypn - 12 bayt **

K

JohnE - 13 bayt

Ti-84 TEMEL

SuperJedi224 - 17 bayt *

R,

MickyT - 23 bayt

OCTAVE / MATLAB

Oebele - 24 bayt

PARI / GP

Charles - 25 bayt **

Wolfram / Mathematica

LegionMammal978 - 27 bayt

Perl

Nutki - 29 bayt

AsciiThenAnsii - 34 bayt

Yakut

Haegin - 32 bayt **

ConfusedMr_C - 51 bayt **

Commodore Basic

Mark - 37 bayt **

PHP

Ismael Miguel - 38 bayt

VBA

Sean Cheshire - 40 bayt **

Güç kalkanı

Nacht - 41 bayt **

JavaScript

Ralph Marshall - 41 bayt

edc65 - 54 bayt (ES6 işlevselliği tüm tarayıcılarda mevcut değildir.)

Lua

kripto - 51 bayt

Java

RobAu - 52 bayt **

Geobits - 65 bayt

C

Functino - 57 bayt

piton

CarpetPython - 58 bayt

Postgre / SQL

Andrew - 59 bayt **

hızlı

Skrundz - 69 bayt

GoatInTheMachine - 81 bayt

Haskell

Zeta - 73 bayt **

ActionScript

Brian - 75 bayt **

> <>

ConfusedMr_C - 76 bayt

GİTMEK

Kristoffer Sall-Storgaard - 78 bayt

C #

Brandon - 91 bayt **

Andrew - 105 bayt

Ewan - 148 bayt

Çizik

SuperJedi224 - 102 bayt

C ++

Michelfrancis Bustillos - 154 bayt

Polyglots

Ismael Miguel (Javascript / ActionScript2) - 67 bayt

Top 10 Genel

Maltysen
Alex A
Jakube
Doktoru
ɐɔıʇǝɥʇuʎs / Ypnypn (sipariş belirsiz)
Johne
SuperJedi224
MickyT
Oebele

Programlandı olarak işaretlendi ** Henüz düzgün bir şekilde test yapamadım

Pyth - 9 8 bayt

Randint toplamının bariz basit yöntemini kullanır. Bana sandığından için dakika sürdü 1048576oldu 2^20, şimdi gerçekten aptal hissediyorum. @Jakube'e işaret ederek bana bir bayt kazandığı için teşekkürler 2^20 = 4^10.

smhO4^4T

Çalışma zamanı korkunç, henüz bilgisayarımda bitmedi, bu yüzden çevrimiçi çalışmanın bir anlamı yok, işte burada 2^10: Burada çevrimiçi deneyin .

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 bayt

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

Toplamı, sondaki yeni satır olmadan yazdırır. Maltysen
yerine 2**20(teşekkürler) ve baskı etrafında tırnak kaldırarak 4 bayt kaydedildi .
Kodu yeniden düzenleyerek başka bir 7 bayt kaydetti (teşekkürler Thaylon!)
Eski kodum 0-4 (1-4 olmalıdır) ürettiği için 2 bayt kaybetti.
Bir kez daha, Caek ve nutki sayesinde 5 bayt tasarruf etti.

Ungolfed, düzgün yazılmış kod:

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

APL, 11 10 bayt

+/?4⍴⍨2*20

Bu sadece 1 ile 4 arasında 2 ²⁰ = 1048576 rasgele tam sayı dizisinin toplamını alır .

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

Bunu TryAPL'de kıyaslayabilirsiniz ve sonra zaman damgasını yazdırarak . Yaklaşık 0.02 saniye sürer.

Marinus ve FUZxxl sayesinde bir bayt kurtardı!

Ti-84 Basic, 17 bayt

Toplam kaplama alanı - Program başlığının boyutu = 17 bayt

Çalışma Süresi: Bilinmiyor, daha az sayıda rulo için performansa bağlı olarak 5-6 saat olarak tahmin edildi (yani temelde çok iyi değil)

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

R, 32 24 23 21 bayt

Düzenleme: Kurtulmuş as.integerve kullanılan tamsayı bölümü%/% . Biraz hızlandır.

Numune ipucu için Alex A'ya ve ... r=

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

İle test edildi

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)

çıktılar

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

Saf hız için aşağıdakiler mikrosaniye olarak tamamlanır. Ancak bunun için mantığımı doğru yaptığımdan emin değilim. Sonuçlar rastgele yöntemle tutarlı görünmektedir. Utanç daha uzun bir uzunluk.

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

İşte makinemde yaptığım bir zamanlama koşusu

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 bayt

İşletim sisteminden 1048576 rastgele karakter alıyoruz, her biri 2 bit alıyor ve ekliyoruz. osKütüphaneyi kullanmak, kütüphaneyi kullanmak için birkaç karakter kaydetmiş gibi görünüyor random.

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

Bu, bilgisayarımda yaklaşık 0,2 saniye sürüyor.

CJam, 12 11 bayt

YK#_{4mr+}*

Bu oldukça düz bir 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)

Ama bunun güzelliği de gerçekten hızlı olması! Makinemde (ve Java derleyicisini kullanarak ) ortalama 70 milisaniye sürer.

Online versiyonu benim makinede 1.7 saniye sürer.

Güncelleme : DocMax sayesinde 1 bayt kaydedildi

JavaScript (ES6), 54 bayt

Ortalama süre <100 milisaniye. Test etmek için snippet'i çalıştırın (Firefox'ta)

// 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>

açıklama

Yerleşik hiçbir istatistik paketi olmadan, Javascript'te 1 milyon rasgele sayı toplamını elde etmenin en kısa yolu bir milyon kez random () çağırmaktır. Yani basitçe

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
}

Şimdi, bir milyon kez 1 eklemek, 1 milyon veya daha da iyisi toplamı 1 milyonla başlatmak ve geri kalanını eklemekle tamamen aynıdır:

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
}

Daha sonra golf, r geçici değişkenini bırakın ve yerel değişkenlerin bildirimini bırakın. tbildirimini kısaltmak için gerekli olan bir parametredir f. iküresel (kötü bir şey)

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

Ardından isimsiz bir iç işlev kullanarak 'geri dönmek' için bir yol bulun. Bir yan etki olarak, başka bir parametre elde ediyoruz, böylece hiçbir global

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

Gerekli uzunlukta bir tablo oluşturur.

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

J (12 bayt, yaklaşık 9.8 milisaniye)

+/>:?4$~2^20

Bunun çoğunlukla bellek bant genişliği sınırlı olduğundan şüpheleniyorum: Tek bir çekirdeği maksimize edemiyorum ...

Bunu aşağıdaki kodla test edebilirsiniz:

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

Bu, onu 20 parkurdan oluşan 4 grupta çalıştırır ve en hızlı gruptaki ortalama sürenin milisaniye sayısını döndürür. Bir tercüman bulunabilir burada .

Pyth, 10 bayt

u+GhO4^4TZ

Bu, @ Maltysen'in Pyth çözeltisinden biraz daha fazla bayta sahiptir. Ancak dizüstü bilgisayarımda 8.5 saniye içinde çalışıyor, @ Maltysen'in çözümü 20 dakika çalışma süresinde çözüm üretmedi.

Ama yine de çevrimiçi derleyici için biraz fazla yavaş.

açıklama

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

Dile göre listelenen puanlarımız olduğundan, Java'yı neden karışıma atmıyorsunuz? Burada golf yapmak için çok fazla bir şey yok, sadece basit bir döngü, ama ilk denememden birkaçını sıkabildim:

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

Matlab, 24

İlk başvuru!

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

1048576 elementli bir matris veren randi'yi ([1,4], 1024) kullanmayı umuyordum, ancak daha sonra bu karakterden daha fazla karakter alan bir çift toplam gerekiyordu.

Soruda belirtilen çalışma hızı timeitile ilgili olarak, çalışma zamanının yaklaşık 0.031 saniye olduğunu söylüyor. Yani, hemen hemen.

Haskell, 73 bayt

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

Kullanımı:

$ ghci sourcefile.hs
ghci> f
2622130

C #: 105 bayt

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 bayt

Bu çok basit bir fikir kullanıyor: hepsini topla!

Ayrıca, bunu fark ettik 1048576olduğu 10000000000000000000ikili düzende eşdeğer 1<<20.

İşte kod:

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

Tarayıcınızda test edin ( ÇOK KÜÇÜK değişikliklerle):

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

Koddaki tüm değişiklikler yorumlarda açıklanmıştır.

Mathematica, 30 27 bayt

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

Mathematica'nın oldukça uzun fonksiyon isimleri var ...

C, 57 bayt

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

Bu kod ... bir kez çalýţýyor. Bu zarları tekrar yuvarlamanız gerekiyorsa srand(time(0)), 14 bayt ekleyerek oraya koymanız gerekir .

PostgreSQL, 59 bayt

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

random()Teorik olarak tam olarak sıfır üretebilen ufak bir problemi kabul edeceğim , bu durumda kalıp rulosu sıfır olacaktır.

Ruby, 32 bayt

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

Daha okunabilir bir biçimde:

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

1 ile 1048576 arasında bir aralık oluşturur ve daha sonra blok üzerinde birçok kez yinelenir. Blok her yürütüldüğünde önceki yinelemeden alınan değer x(başlangıçta 0, için varsayılan inject) olarak iletilir . Her yineleme, 0 ile 3 (dahil) arasında rastgele bir sayı hesaplar, bir ekler, böylece bir d4 yuvarlanmasını simüle eder ve toplama ekler.

Makinemde çalıştırmak oldukça hızlı ( 0.25 real, 0.22 user, 0.02 sys).

Ruby yüklüyse ruby -e 'p (1..2**20).inject{|x|x+rand(4)+1}'(p bu şekilde çalıştırmak çıkış görmek gerekir ihmal onu bunun için umursamazsak ya da sadece sonuç ekranına yazdırıldığı yere lRB içine çalıştırmak senin için). Ruby 2.1.6'da test ettim.

Onun yerine biraz kıvrık kesmek için histokrat x + rand(4) + 1sayesinde x-~rand(4).

PARI / GP, 25 bayt

Gerçekten, burada golf oynamaya gerek yok - bu GP'de hesaplama yapmanın kolay yoludur. Makinemde 90 milisaniyede çalışıyor. Kaldırma +1yaklaşık 20 milisaniye tasarruf sağlar.

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

Sadece eğlence için: PARI'daki performans için optimize edilseydi,

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

çok küçük bir toplam işlem sayısı vardır - eğer xorgens 64 bit sözcük başına ~ 27 döngüye ihtiyaç duyarsa (herkes bunu doğrulayabilir mi?), o zaman POPCNT'li bir işlemci sadece yaklaşık 0.5 döngü / bit veya final için birkaç yüz mikrosaniye sürmelidir numara.

Bu, benzer veya daha yüksek kalitede rasgele sayılar kullanan yöntemler arasında optimal-en kötü durum performansına sahip olmalıdır. Olguları bir seferde belki bir milyon rulo ile birleştirerek ve (esasen) aritmetik kodlama ile seçerek ortalama hızı büyük ölçüde artırmak mümkün olmalıdır .

Javascript, 55 53 50 47 41 bayt

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

Rastgele olmayan sayıların bilinen bir tahriş edici olduğunu fark etmedim, bu yüzden gerçek bir çözüm yayınlamam gerektiğini anladım. Saygısızlık demek istemedim.

Yorum: yukarıdaki diğerleri tarafından belirtildiği gibi, cevabınızdaki rulo sayısıyla başlayarak ve her bir ruloya +1 atlayabilirsiniz ve a = 0 yazmak zorunda kalmadan iki bayt kaydedersiniz ve başka 2 çünkü her ruloya +1 eklemezsiniz. ParseInt işlevi Math.floor ile aynı şeyi yapar, ancak 2 karakter daha kısadır.

Klip 10 , 12 bayt

r+`m[)r4}#WT

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

Makinemde çalışmak yaklaşık 0.6 saniye sürer.

Git, 78 bayt

golfed

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

Hala üzerinde çalışıyor

Çevrimiçi olarak buradan çalıştırın http://play.golang.org/p/pCliUpu9Eq

Git, 87 bayt

Saf çözüm

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

Çevrimiçi olarak buradan çalıştırın: http://play.golang.org/p/gwP5Os7_Sq

Go oyun alanının çalışması nedeniyle, tohumu manuel olarak değiştirmeniz gerekir (zaman her zaman aynıdır)

Commodore Basic, 37 bayt

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

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

Daha düşük zar sayısına sahip koşulara dayalı tahmini çalışma süresi: 4.25 saat.

CRastgele sayıların örtülü yuvarlanmasını sağlayarak bir tamsayı yaparak iki bayttan golf oynamaya çalışmak caziptir . Ancak, Commodore Basic içindeki tamsayılar aralığı -32678 ila 32767'dir - medyan cevap 2621440 olduğunda yeterli değildir.

PowerShell, 41 37 bayt

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

Makinemi 2 dakika 40 saniye aldı

Yakut, 51 47 karakter

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

Bunu yapmadan önce tüm cevaplara baktım ve sum(2**20 times {randInt(4)})strateji gerçekten dışarı çıktı, ben de kullandım.

> <>, 76 karakter

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

Bunun işe yarayıp yaramadığından emin değilim, çünkü test etmeye çalıştığımda tarayıcım çöktü, ama işte çevrimiçi tercüman.

Hızlı, 64 bayt

Swift'te zeki, golf yapmak zor değil ...

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

Sürüm 2 (çok geç)

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