शॉक प्रोब से मौत: यह एक बहुत पासा है

20

वेबकॉमिक में Darths और खड़े छोड़ दिया , पीट, जो काल्पनिक भूमिका अभियान में R2-D2 निभाता है जो चारों ओर हास्य आधारित है, एक बार का दावा (चेतावनी: संभावित विफल जुड़ा हुआ हास्य में) है कि, Phanastacoria का खोया Orb के साथ अप करने के लिए धांधली उसकी सदमे की जांच, वह अब बाहर 1048576d4 पकवान कर सकते हैंक्षति के। (जीएम ने इस बात की न तो पुष्टि की है और न ही खंडन किया है।) क्योंकि यह स्पष्ट रूप से स्पष्ट होना चाहिए कि लगभग किसी के पास वास्तव में यह रोल करने के लिए धैर्य नहीं होगा कि कई पासा, उसके लिए ऐसा करने के लिए एक कंप्यूटर प्रोग्राम लिखें, कुल मूल्य को कुछ उचित तरीके से लुढ़का। प्रारूप। एंट्री को कार्यक्रम के आकार (सबसे छोटे कार्यक्रम, बाइट काउंट, जीत) से, कुल मिलाकर और प्रति-भाषा दोनों के साथ चलाया जाएगा, जिसमें रनिंग ब्रेकिंग संबंध होंगे। उत्तर पूर्ण प्रोग्राम या फ़ंक्शन परिभाषा हो सकता है।

प्रति भाषा स्कोर

Pyth

माल्टीसेन - 8 बाइट्स *

जक्यूब - 10 बाइट्स

एपीएल

एलेक्स ए - 10 बाइट्स

CJam

ऑप्टिमाइज़र - 11 बाइट्स

जे

ɐɔıɐɔuɐɔs - 12 बाइट्स **

Clip10

Ypnypn - 12 बाइट्स **

कश्मीर

जॉन - 13 बाइट्स

टीआई -84 बुनियादी

SuperJedi224 - 17 बाइट्स *

आर

मिकी - 23 बाइट्स

OCTAVE / MATLAB

ओबेले - 24 बाइट्स

PARI / जीपी

चार्ल्स - 25 बाइट्स **

Wolfram / मेथेमेटिका

लीजनमैमल 978 - 27 बाइट्स

पर्ल

नटकी - 29 बाइट्स

AsciiThenAnsii - 34 बाइट्स

माणिक

Haegin - 32 बाइट्स **

ConfusedMr_C - 51 बाइट्स **

कमोडोर बेसिक

मार्क - 37 बाइट्स **

पीएचपी

इस्माइल मिगुएल - 38 बाइट्स

VBA

सीन चेशायर - 40 बाइट्स **

शक्ति कोशिका

नच - 41 बाइट्स **

जावास्क्रिप्ट

राल्फ मार्शल - 41 बाइट्स

edc65 - 54 बाइट्स (सभी ब्राउज़रों में ES6 कार्यक्षमता की आवश्यकता नहीं है।)

लुआ

क्रिप्टिक - 51 बाइट्स

जावा

रोबू ​​- 52 बाइट्स **

Geobits - 65 बाइट्स

सी

फंपीनो - 57 बाइट्स

अजगर

कारपेटपाइथन - 58 बाइट्स

Postgre / एसक्यूएल

एंड्रयू - 59 बाइट्स **

तीव्र

Skrundz - 69 बाइट्स

GoatInTheMachine - 81 बाइट्स

हास्केल

ज़ेटा - 73 बाइट्स **

ActionScript

ब्रायन - 75 बाइट्स **

> <>

ConfusedMr_C - 76 बाइट्स

जाओ

क्रिस्टोफ़र साल्-स्टोर्गार्ड - 78 बाइट्स

सी#

ब्रैंडन - 91 बाइट्स **

एंड्रयू - 105 बाइट्स

इवान - 148 बाइट्स

खरोंच

सुपरजेडी 224 - 102 बाइट्स

सी ++

मिशेलफ्रिस बस्टिलोस - 154 बाइट्स

polyglots

इस्माइल मिगुएल (जावास्क्रिप्ट / एक्शनस्क्रिप्ट 2) - 67 बाइट्स

शीर्ष 10 समग्र

Maltysen
एलेक्स ए
Jakube
अनुकूलक
ɐɔınuɐɔs / Ypnypn (आदेश अनिश्चित)
JohnE
SuperJedi224
MickyT
Oebele
चेतावनी- एक * से चिह्नित प्रविष्टियाँ बहुत धीमी हैं।

क्रमादेशित चिह्नित ** मैं अभी तक ठीक से परीक्षण नहीं कर पाया हूं

code-golf  random 
— SuperJedi224
स्रोत
रुको, क्या मुझे एक सूची में पासा रोल या सिर्फ सभी रोल का योग देना है?
— माल्टीसेन
5
आपका प्रश्न, जैसा कि यह खड़ा है, संभवतः अस्पष्ट होने या अत्यधिक व्यापक होने के लिए आलोचना की जाएगी। यदि आप विशिष्ट, वस्तुनिष्ठ शब्दों में वर्णित हैं कि कार्यक्रम कैसे बनाए जाएंगे और उनके लिए कौन से तरीके उपलब्ध होने चाहिए, तो यह बहुत उपयोगी होगा। इसके अलावा, 1048576d4कुछ उपयोगकर्ताओं के लिए यह संकेत अस्पष्ट हो सकता है। यह ठीक-ठीक वर्णन किया जाना चाहिए कि क्या गणना की जानी चाहिए, और किसी भी दिशानिर्देश का पालन किया जाना चाहिए।
— BrainSteel
2
एक अच्छा समय परीक्षण होने के लिए यह समस्या बहुत जल्दी हो सकती है।
— इसहाक
12
मैन्युअल रूप से प्रस्तुतियाँ की सूची को बनाए रखने से बचने के लिए आप स्टैक स्निपेट लीडरबोर्ड बनाने में अपना हाथ आज़मा सकते हैं ।
— एलेक्स ए।
1
मुझे यह शीर्षक बहुत पसंद है।
— ASCIIThenANSI

जवाबों:

10

पायथ - 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
— Maltysen
स्रोत
4
8 बाइट संभव हैं। 2^20 = 4^10
— जेक्यूब
@ जेक्यूब टिप के लिए धन्यवाद :)
— माल्टसेन
यह मेरे लिए तुरंत खत्म होता है।
— कैरिजनेट
@Carcigenicate क्या आप मेरे द्वारा दिए गए लिंक के बारे में बात कर रहे हैं? यह संशोधित है, केवल रकम है 1024d4।
— माल्टसेन
@ मैलेट्सन व्हाट्स, सॉरी। हां, यह बात है।
— कैरिजनेट
9

पर्ल - 48 44 37 39 34 बाइट्स

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

एक अनुगामी newline के बिना राशि प्रिंट करता है। (धन्यवाद माल्टीसेन) के
लिए प्रतिस्थापित करके 2**20और प्रिंट के आसपास उद्धरणों को हटाकर 4 बाइट्स बचाए।
कोड को फिर से व्यवस्थित करके एक और 7 बाइट्स को बचाया (धन्यवाद थाइलोन!)
2 बाइट्स खो दिया क्योंकि मेरा पुराना कोड 0-4 (यह 1-4 होना चाहिए)।
एक बार फिर से कैक और नटकी की बदौलत 5 बाइट्स बचाए।

अघोषित, ठीक से लिखा कोड:

my $s = 0
$s += int( rand(4) + 1 ) for (1 .. 2**20);
print "$s";
— ASCIIThenANSI
स्रोत
टाइमर को हुक करना थोड़ा कठिन था, लेकिन मैंने आखिरकार इसे काम कर लिया।
— SuperJedi224
2
चूँकि हम चेतावनियों की परवाह नहीं करते ... $ s + = int रैंड (5) के लिए (1..2 ** 20); प्रिंट $ s
— थाओलोन
3
int(rand(5))रिटर्न रेंज 0 से 4 जबकि
— d4
@ कुटकी ओके, धन्यवाद। मैंने अब इसमें संपादन किया है।
— ASCIIThenANSI
$s+=int rand(4)+1for(1..2**20);print$sInt के लिए कोष्ठक निकालना भी मेरे लिए काम करता है, एक स्ट्रोक को बचाने के लिए।
— काक
7

एपीएल, 11 10 बाइट्स

+/?4⍴⍨2*20

यह सिर्फ 1 और 4 के बीच 2 20 = 1048576 यादृच्छिक पूर्णांकों की एक सरणी का योग लेता है ।

+/           ⍝ 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 के लिए बाइट धन्यवाद!

— एलेक्स ए।
स्रोत
एक और 5 ??? एक d4 1, 2, 3 या 4 दे सकता है। आप 5 प्राप्त नहीं कर सकते
— लोरेन Pechtel
@ लोरेनपेकटेल: क्षमा करें, मेरा बुरा। यह बात बताने के लिए धन्यवाद। यह अब तय हो गया है। मेरे पास दिमाग थका हुआ है।
— एलेक्स ए।
एक बाइट सहेजें: +/?4⍴⍨2*20
— marinus
छोटा सुधार: +/?4⍴⍨2*20इसके बजाय उपयोग करें ।
— फ़ूजएक्सएक्सएल
1
आकस्मिक रूप से, यह उत्तर किसी भी तरह से गढ़ा नहीं गया है: यह उत्पादन एपीएल कोड में बिल्कुल उसी तरह लिखा जाएगा।
— फ़ूजएक्सएक्सएल
7

टीआई -84 बेसिक, 17 बाइट्स

कुल पदचिह्न - कार्यक्रम हेडर का आकार = 17 बाइट्स

रन टाइम: अज्ञात, अनुमानित 5-6 घंटे रोल की छोटी संख्या के लिए प्रदर्शन के आधार पर (इसलिए, मूल रूप से, बहुत अच्छा नहीं)

Σ (randInt (1,4), ए, 1,2 ^ 20
— SuperJedi224
स्रोत
1
इसे TI-84 पर चलाने के लिए +1। मुझे लगता है कि समय यहाँ एक समस्या नहीं है, उन 30-40 साल पुराने कैलकुलेटर हैं।
— ASCIIThenANSI
मुझे लगता है कि एक समान वितरण के बजाय एक सामान्य वितरण का नमूना लेने के लिए एक समारोह है? ज्यादा तेज होना चाहिए।
— बेन वोइग्ट
@BenVoigt: चूंकि यह पासा के रोलिंग का अनुकरण करने के लिए है, एक सामान्य वितरण उचित नहीं है; यह एकरूप होना होगा।
— एलेक्स ए।
2
@ एलेक्सा: केंद्रीय सीमा प्रमेय प्रदान करता है कि कई समान पासा का योग एक सामान्य वितरण से अप्रभेद्य है। तो यह इस बात पर निर्भर करता है कि हम "अनुकरण रोलिंग" के बारे में कितने पांडित्यपूर्ण हैं।
— बेन वोइग्ट
1
@ सीधे, मुझे लगा कि यह सिर्फ संचार के लिए था। कम से कम जो मुझे मिला है वह एएए बैटरी का उपयोग करता है।
— आर्टुरो टॉरेस सैंचेज़
7

आर, 32 24 23 21 बाइट्स

संपादित करें: as.integerपूर्णांक विभाजन से छुटकारा और उपयोग किया गया %/%। इसे थोड़ा तेज करो।

नमूना को हटाने के लिए एलेक्स ए ... और 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
— MickyT
स्रोत
के sample()स्थान पर runif(), यानी का उपयोग करके आप कुछ बाइट्स बचा सकते हैं sum(sample(4,2^20,r=T))।
— एलेक्स ए।
बस अपने कंप्यूटर पर कुछ बेंचमार्किंग किया और sample()वास्तव में तेज भी है!
— एलेक्स ए।
@AlexA। धन्यवाद जब मैं एक कंप्यूटर के करीब
— पहुंचूंगा,
इस या कुछ भी नहीं करने के लिए नहीं r=T, लेकिन आप की जरूरत नहीं है , बस Tप्रतिस्थापन के लिए ठीक है।
— ग्यूसेप
1
@Giuseppe, धन्यवाद .. यह वास्तव में एक पुराना था
— मिकी टन
6

पायथन 2, 58 बाइट्स

हम ऑपरेटिंग सिस्टम से 1048576 यादृच्छिक वर्ण प्राप्त करते हैं, प्रत्येक के 2 बिट्स लेते हैं, और उन्हें जोड़ते हैं। osपुस्तकालय का उपयोग करने के लिए पुस्तकालय का उपयोग कर कुछ पात्रों को बचाने के लिए लगता है random।

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

यह मेरे पीसी पर लगभग 0.2 सेकंड लेता है।

— तर्क नाइट
स्रोत
6

सीजेएम, 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)

लेकिन इस की सुंदरता यह है कि इसका वास्तव में उपवास भी है! मेरी मशीन पर (और जावा कंपाइलर का उपयोग करके ) यह औसतन ec० मिलीसेकेंड लेता है।

ऑनलाइन संस्करण मेरी मशीन पर 1.7 सेकंड के आसपास लेता है।

अद्यतन : 1 बाइट DocMax के लिए धन्यवाद बचाया

— अनुकूलक
स्रोत
ऑनलाइन संस्करण यहां कंप्यूटरों से लगभग 6 सेकंड ले रहा है, लेकिन शायद यह सिर्फ नेटवर्क है और / या मैकबुक का उपयोग करने पर जोर देता है। घर पहुँचते ही फिर से कोशिश करूँगा।
— SuperJedi224
@ SuperJedi224 ऑनलाइन संस्करण सभी जावास्क्रिप्ट में है, कोई नेटवर्क कॉल नहीं करता है। आप जावा संस्करण डाउनलोड कर सकते हैं और इसे वेबसाइट पर दिए गए निर्देशों का उपयोग करके चला सकते हैं।
— ऑप्टिमाइज़र
3
जब तक मुझे कुछ याद नहीं है (जो कि सीजेएम और मेरे साथ बहुत दुख की बात है), 0 के साथ बोने के बजाय और 2 ^ 20 रन के लिए 1 जोड़कर, 1 बाइट बचाने के लिए 2 ^ 20 के साथ बीज:YK#_{4mr+}*
— DocMax
@DocMax आप सही हैं। धन्यवाद!
— ऑप्टिमाइज़र
+1; मैं इस सटीक उत्तर को पोस्ट करने जा रहा था (इसके 4A#बजाय को छोड़कर YK#), लेकिन आपने मुझे इसके लिए हराया। :)
— इल्मरी करोनन
6

जावास्क्रिप्ट (ईएस 6), 54 बाइट्स

औसत समय <100 मिसे। परीक्षण करने के लिए स्निपेट चलाएँ (फ़ायरफ़ॉक्स में)

// 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>
स्निपेट का विस्तार करें

व्याख्या

जावास्क्रिप्ट में बिल्ट-इन कोई सांख्यिकीय पैकेज नहीं होने के कारण, 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 मिलियन को जोड़ने की तुलना में बिल्कुल समान है, या इससे भी बेहतर, 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
}

फिर गोल्फ, अस्थायी चर आर ड्रॉप और स्थानीय चर की घोषणा ड्रॉप। 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
— edc65
स्रोत
क्रोम में काम नहीं करता है। एफएफ में परीक्षण के बारे में।
— SuperJedi224
बेशक। Chrome
— ES5
1
इसमें कुछ ES6 समर्थन हैं (जिनमें से अधिकांश क्रोम से प्रयोगात्मक जावास्क्रिप्ट को सक्षम करके ही उपलब्ध है: \\ झंडे), लेकिन अभी तक तीर कार्यों का समर्थन नहीं करता है
— SuperJedi224
5

पर्ल, २ ९

आवश्यक लंबाई की एक तालिका बनाता है।

print~~map{0..rand 4}1..2**20
— nutki
स्रोत
मुझे इस पर एक सिंटैक्स त्रुटि मिल रही है।
— SuperJedi224
इसके लिए पर्ल के नए पर्याप्त संस्करण की आवश्यकता है (स्मार्टमैच ऑपरेटर को 5.10.1 में पेश किया गया था, और मुझे लगता है कि इसे डिफ़ॉल्ट रूप से बाद में उपलब्ध नहीं कराया गया था)।
— मार्क
~~एक स्मार्टमैच नहीं है, बस स्केलर संदर्भ को मजबूर करने के लिए एक डबल बिट उलटा है। एक चरित्र लंबा रास्ता होगा print$x=map...। हो सकता है कि नए संस्करणों पर यह स्मार्टमैच के साथ अस्पष्टता के कारण चेतावनी देता है, लेकिन यह मेरे सिस्टम पर और यहां चेतावनी के बिना काम करने लगता है: ideone.com/LAIWzq
— Nutki
हां, यह IDEone पर काम करता है। मैं तुम्हें यह दूँगा।
— SuperJedi224
5

जे (12 बाइट्स, लगभग 9.8 मिलीसेकंड)

+/>:?4$~2^20

मुझे संदेह है कि यह ज्यादातर मेमोरी बैंड-सीमित है: मैं इसे एक कोर को अधिकतम करने के लिए भी नहीं मिल सकता ...

आप निम्न कोड के साथ यह परीक्षण कर सकते हैं:

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

यह इसे 20 ट्रेल्स के 4 समूहों में चलाता है, और सबसे तेज समूह में औसत समय के मिलीसेकंड की संख्या लौटाता है। एक दुभाषिया यहाँ पाया जा सकता है ।

— ɐɔıʇǝɥʇuʎs
स्रोत
4

अजगर, 10 बाइट्स

u+GhO4^4TZ

यह @ माल्टीसेन के पाइथ समाधान की तुलना में थोड़ा अधिक बाइट्स है। लेकिन यह मेरे लैपटॉप पर 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
— Jakube
स्रोत
आज दोपहर को परीक्षण करेंगे।
— SuperJedi224 13
4

जावा, 65

चूंकि हमारे पास भाषा द्वारा सूचीबद्ध स्कोर हैं, इसलिए जावा को मिश्रण में क्यों नहीं फेंकना चाहिए? यहां गोल्फ के लिए बहुत कुछ नहीं है, बस एक साधारण लूप है, लेकिन मैं अपने शुरुआती प्रयास में एक जोड़े को निचोड़ने में सक्षम था:

int f(){int i=1<<20,s=i;while(i-->0)s+=Math.random()*4;return s;}
— Geobits
स्रोत
आज दोपहर को परीक्षण करेंगे।
— SuperJedi224 13
कोई दिक्कत नहीं है। इस (धीमी) पीसी पर लगभग 80ms लगते हैं, लेकिन मुझे नहीं पता कि आप समय का क्या उपयोग कर रहे हैं।
— Geobits
मुझे विश्वास नहीं है कि आपका कार्यक्रम एक सही मॉडल है। यह मेरे परीक्षण में कुछ रोल पर 0 जोड़ सकता है। जैसा कि मैं समझता हूं कि यह सबसे d4 के 1,2,3,4 (कोई 0 संभव नहीं) हैं।
4
@ user39526 s(कुल योग) शुरू होता है 1<<20(रोल की संख्या)। यह प्रत्येक रोल में एक जोड़ने के बराबर है। जब रैंडमाइज़र 0 फेंकता है, तो यह 1 रोल किया जाता है, आदि
— जियोबिट्स
आपको Java 8 में अपग्रेड करना चाहिए! codegolf.stackexchange.com/a/52919/7021
— RobAu
4

मतलूब, २४

पहले कभी प्रस्तुत! 

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

मुझे रंडी ([1,4], 1024) का उपयोग करने की उम्मीद थी, जो 1048576 तत्वों का एक मैट्रिक्स देता है, लेकिन फिर मुझे एक डबल राशि की आवश्यकता थी, जो इससे अधिक वर्ण लेता है।

प्रश्न में उल्लेखित गति के बारे में, timeitमुझे बताता है कि रनटाइम लगभग 0.031 सेकंड है। तो, बहुत ज्यादा तात्कालिक है।

— Oebele
स्रोत
मैं ऑनलाइन ऑक्टेव के माध्यम से 0.04 से 0.05 सेकंड प्राप्त कर रहा हूं।
— SuperJedi224
4

हास्केल, 73 बाइट्स

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

उपयोग:

$ ghci sourcefile.hs
ghci> f
2622130
— जीटा
स्रोत
4

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));}}
— एंड्रयू
स्रोत
अच्छा, मुझे यह पसंद है भले ही यह दो बार गलत हो। यह 1 << 20 है, 2 << 20 नहीं। और The *exclusive* upper bound of the range
— Random.Next
@ edc65 उन त्रुटियों को पकड़ने के लिए धन्यवाद। मैंने जवाब अपडेट कर दिया है।
— एंड्रयू
1
आप को हटाने aऔर new System.Random()अंदर की ओर बढ़ने से 9 वर्णों को बचा सकते हैं Sum। निश्चित रूप से, यह Randomहर बार एक नया निर्माण करेगा , लेकिन जब तक यह परिणाम देता है, तब तक कौन परवाह करता है?
— लेजिओनमाला 978
@ LegionMammal978 यदि आप बार-बार नया रैंडम बनाते हैं, तो इसका परिणाम ज्यादातर गैर-यादृच्छिक है
— edc65
@ edc65 यही कारण है कि मैं उस मार्ग पर नहीं गया। अगर मुझे सुझाव का पालन करना है तो मुझे यह परखने का मौका नहीं है।
— एंड्रयू
4

पीएचपी, 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);

कोड स्निपेट दिखाएं

कोड में सभी परिवर्तनों को टिप्पणियों में समझाया गया है।

— इस्माइल मिगुएल
स्रोत
आप ;बाद को हटा सकते हैंecho$v
— मार्टिज़न
@Martijn मैंने इसे वहां छोड़ दिया क्योंकि ज्यादातर समय PHP इसके बारे में शिकायत करता है। लेकिन मैंने अब इसे हटा दिया है। यह sandbox.onlinephpfunctions.com पर काम करता है और यह पर्याप्त है।
— इस्माइल मिगुएल
4

गणितज्ञ, 30 27 बाइट्स

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

मैथेमेटिका में काफी लंबे समारोह के नाम हैं ...

— LegionMammal978
स्रोत
3

सी, 57 बाइट्स

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

यह कोड काम करता है ... एक बार। यदि आपको कभी भी उन पासा को फिर से रोल करने की आवश्यकता होती है, तो आपको srand(time(0))14 बाइट्स जोड़कर, वहां डालनी होगी।

— Functino
स्रोत
आपको जोड़ने की आवश्यकता क्यों होगी srand(time(0))? (क्षमा करें, मैं C. का उपयोग नहीं करता)
— ASCIIThenANSI
@ASCIIThenANSI सी के randबीज के कई कार्यान्वयन इसे हर मूल्य के समान मूल्य पर देते हैं। srandबीज RNG, और time(0)1970 के बाद से सेकंड में वर्तमान समय हो जाता है
— Functino
यदि आप इनिशियलाइज़ करते हैं a=b=1<<20तो आप स्किप कर सकते हैं 1+, इससे 4 बाइट बचती हैं।
— नटकी
इसके अलावा, intपहले mainकी आवश्यकता नहीं है।
— नटकी
किसी को भी करने के लिए संकेत t=0, फिर t=t (...) +11048576 बार के लिए: फिर से सोचो! (मेरा जवाब देखिए, आखिरकार)
— edc65
3

PostgreSQL, 59 बाइट्स

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

मैं उस मामूली समस्या को स्वीकार करूंगा random(), जो सिद्धांत रूप में, बिल्कुल शून्य का उत्पादन कर सकती है, जिस स्थिति में डाई रोल शून्य होगा।

— एंड्रयू
स्रोत
आपको वास्तव ;में क्वेरी को समाप्त करने की आवश्यकता नहीं है क्योंकि यह केवल एक है
— मिकी
3

रूबी, 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 (समावेशी) के बीच एक यादृच्छिक संख्या की गणना करती है, एक जोड़ता है इसलिए यह एक डी 4 को रोल करने के लिए अनुकरण करता है और कुल में जोड़ता है।

मेरी मशीन पर इसे चलाने के लिए बहुत तेज़ है ( 0.25 real, 0.22 user, 0.02 sys)।

अगर आपको रूबी स्थापित हो गई है तो आप इसे चला सकते हैं ruby -e 'p (1..2**20).inject{|x|x+rand(4)+1}' (p इस तरीके से चलाने पर आउटपुट देखने के लिए आवश्यक है, इसे छोड़ दें यदि आप उस पर ध्यान नहीं देते हैं या आईआरबी के अंदर इसे चलाते हैं जहां परिणाम स्क्रीन पर मुद्रित होता है तुम्हारे लिए)। मैं रूबी 2.1.6 पर यह परीक्षण किया है।

बिट ट्विगलिंग हैक के लिए हिस्टोक्रैट के लिए धन्यवाद जो इसके x + rand(4) + 1साथ बदलता है x-~rand(4)।

— Haegin
स्रोत
1
क्या आप बता सकते हैं कि यह कैसे काम करता है?
— ASCIIThenANSI
पहला ऑनलाइन दुभाषिया मुझे मिल सकता है जो वास्तव में दावे को लोड करना चाहता है कि विधि रैंड () मौजूद नहीं है। मैं एक और एक को खोजने की कोशिश करेंगे।
— SuperJedi224
ठीक है, मैं एक है कि काम करता है पाया।
— SuperJedi224
बिट twiddling हैक: x-~rand(4)के बराबर है x+rand(4)+1।
— histocrat
इसके अलावा, आप बदल सकते हैं 2**20के साथ 4e10।
— histocrat
3

PARI / जीपी, 25 बाइट्स

वास्तव में, यहां गोल्फिंग की कोई आवश्यकता नहीं है - जीपी में गणना करने का यह सीधा तरीका है। यह मेरी मशीन पर 90 मिलीसेकंड में चलाता है। उत्थापन +120 मिलीसेकंड के बारे में बचत होती है।

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 जरूरतों ~ प्रति 64-बिट शब्द 27 चक्र (? कर सकते हैं किसी को भी इस की पुष्टि), तो POPCNT साथ एक प्रोसेसर केवल 0.5 चक्र / बिट, या फाइनल के लिए कुछ सौ माइक्रोसेकंड लेना चाहिए नंबर।

यह करीब-टू-इष्टतम समान या उच्च गुणवत्ता की यादृच्छिक संख्या का उपयोग कर तरीकों के बीच बुरी से बुरी हालत प्रदर्शन होना चाहिए। एक समय में हो सकता है एक लाख रोल - - और (अनिवार्य) के साथ का चयन यह बहुत मामलों के संयोजन से औसत गति को बढ़ाने के लिए संभव हो जाना चाहिए गणित कोडिंग ।

— चार्ल्स
स्रोत
3

जावास्क्रिप्ट, 55 53 50 47 41 बाइट्स

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

मुझे महसूस नहीं हुआ कि गैर-यादृच्छिक संख्या एक ज्ञात अड़चन थी, इसलिए मुझे लगता है कि मुझे एक वास्तविक समाधान पोस्ट करना चाहिए। कोई अनादर मायने रखता था।

टिप्पणी: के रूप में दूसरों के द्वारा ध्यान दिया इसके बाद के संस्करण आप अपने जवाब में रोल की संख्या के साथ बंद शुरू करने से प्रत्येक रोल करने के लिए +1 को छोड़ सकते हैं, और एक = 0 लिखने के लिए नहीं होने से, मैं = 1 << 20 आप दो बाइट्स बचाने के लिए, और एक और 2 क्योंकि आप प्रत्येक रोल करने के लिए +1 न जोड़ें। parseInt समारोह Math.floor के रूप में एक ही बात करता है लेकिन 2 वर्ण कम है।

— राल्फ मार्शल
स्रोत
ध्यान दें कि यह जवाब एक मूल रूप से SuperJedi224 और @Andrew द्वारा उस टिप्पणी से पूरी तरह अलग है
— राल्फ मार्शल
आप दोनों कोष्ठक और पिछले अर्धविराम (और केवल पिछले एक) नीचे कुछ आगे पात्रों कटौती करने के लिए निकाल सकते हैं। इसके अलावा, वर्तमान संस्करण केवल 50 वर्णों का है, 52 का नहीं।
— सुपरजेडी224
सुपरजेडी - सुझावों के लिए धन्यवाद। मैंने सोचा था कि मैं इसे बिना किसी समस्या के चलाने के लिए कोष्ठक के बिना कोशिश करूँगा, लेकिन शायद मुझे एक अलग समस्या थी। किसी भी मामले में, मुझे लगता है कि यह उतना ही अच्छा है जितना कि यह मिलने वाला है।
— राल्फ मार्शल
a+=parseInt(Math.random()*4)को छोटा किया जा सकता है a+=1+Math.random()*4&7। 1+केवल है अगर आप परवाह अगर यह रोल 0 या नहीं।
— इस्माईल मिगुएल
यह गोल्फ आप कर सकते हैं नीचे यह करने के लिए: for(a=i=1<<20;i--;)a+=(Math.random()*4)|0, केवल 41 बाइट्स है कि
— SuperJedi224
2

10 क्लिप , 12 बाइट्स

r+`m[)r4}#WT

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

यह मेरी मशीन पर चलने के लिए लगभग 0.6 सेकंड लेता है।

— Ypnypn
स्रोत
2

जाओ, 78 बाइट्स

golfed

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

— Kristoffer Sall-Storgaard
स्रोत
दुर्भाग्य से, golang.org खेल का मैदान समय संचालन ठीक से लागू नहीं करता है और repl.it एक अभी लोड करने के लिए नहीं चाहता है। मैं क्या मैं इसके बारे में आज दोपहर क्या कर सकते हैं देखेंगे।
— SuperJedi224
2

जाओ, 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

तरीके के कारण पर जाएं खेल का मैदान काम करता है आप मैन्युअल रूप से बीज बदलना होगा (समय हमेशा एक ही है)

— Kristoffer Sall-Storgaard
स्रोत
2

कमोडोर बेसिक, 37 बाइट्स

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

PETSCII प्रतिस्थापन: ─= SHIFT+E, /= SHIFT+N, ┌=SHIFT+O

4.25 घंटे अनुमानित क्रम कम पासा मायने रखता है के साथ रन पर आधारित है।

यह Cएक पूर्णांक बनाने के लिए दो बाइट्स से गोल्फ को आज़माने का प्रलोभन दे रहा है, यादृच्छिक संख्याओं के निहित गोलाई प्राप्त कर रहा है। हालांकि, कमोडोर बेसिक में पूर्णांकों की सीमा -32678 से 32767 तक है - पर्याप्त नहीं है, जब औसत उत्तर 2621440 है।

— निशान
स्रोत
2

रूबी, 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+
  >>>> >?!^^

मुझे यकीन नहीं है कि यह काम करता है, क्योंकि जब मैंने इसका परीक्षण करने की कोशिश की, तो मेरा ब्राउज़र क्रैश हो गया, लेकिन यहां ऑनलाइन दुभाषिया है।

— ताली
स्रोत
मैं तुम्हें> <> उत्तर के लिए एक +1 दे देंगे।
— SuperJedi224
2

स्विफ्ट, 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)
— GoatInTheMachine
स्रोत
2

जावा (जावा 8) - 52

int f(){return new Random().ints(1<<20,1,5).sum();}
— RobAu
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.