संकट

n=2पासा से शुरू :

रोल nडाईस, प्रत्येक संख्या 1 से 6 के साथ प्रत्येक मरने पर समान रूप से होने की संभावना है।
जांचें कि क्या उनकी राशि nपासा के लिए सबसे संभावित योग के बराबर है, अर्थात 3.5*n।
- यदि वे समान हैं, तो समाप्त करें।
- अन्यथा, पासा के nसाथ शुरू से ही प्रिंट , और दोहराएंn+2

आपके कोड को यह प्रक्रिया ठीक से करने की आवश्यकता नहीं है, लेकिन यादृच्छिकता की हमारी परिभाषा के आधार पर यादृच्छिक आउटपुट को संभाव्य रूप से इसके बराबर देना चाहिए ।

आपके कार्यक्रम को अपनी लाइन पर सभी नंबरों का उत्पादन करना चाहिए; उदाहरण के लिए, यदि प्रोग्राम 8 पासे तक बढ़ा और 8 पासे के साथ सबसे अधिक संभावित संख्या को लुढ़काया, तो आउटपुट होगा:

2
4
6

उदाहरण रन

2 पासा पर, 7सबसे संभावित योग है। मान लीजिए कि रोल किए गए नंबर थे 2और 3। फिर, आप प्रिंट करेंगे 2।

4 पासा पर, 14सबसे संभावित योग है। चलो का कहना है कि संख्या लुढ़का थे 3, 4, 2, और 5। फिर, योग है 14, इसलिए कार्यक्रम यहां समाप्त होगा।

इस मामले में अंतिम आउटपुट है "2"।

नियम

कोड-गोल्फ तो बाइट्स जीत में सबसे कम समाधान है
स्टैंडर्ड लोफॉल्स लागू होते हैं
यादृच्छिकता की मेटा परिभाषा लागू होती है
आप कार्यों के साथ-साथ कार्यक्रमों का उपयोग कर सकते हैं

code-golf random

— zoecarver
स्रोत

यह जवाब, जैसा कि यह खड़ा है, बहुत अस्पष्ट है। क्या कोई इनपुट है, या इसका मतलब है कि लूप के रूप में कोई इनपुट नहीं है? क्या कोई यादृच्छिकता है? मुझे कोई यादृच्छिकता शामिल नहीं लगती है।

— हाइपरनीट्रीनो

वैसे, PPCG में आपका स्वागत है! :)

— हाइपरन्यूट्रीनो

धन्यवाद, क्षमा करें, मैं इसके लिए बहुत नया हूं। इससे क्या स्पष्ट होगा? कोई इनपुट नहीं है, आप एक मरने के साथ शुरू करने वाले हैं और अपने तरीके से काम कर सकते हैं।

— जोकर

@ संभावना अगर मैं सही तरीके से समझूं, तो मुझे 2, 4, 6, 8, ...उस पुनरावृत्ति के लिए सबसे अधिक संभावित संख्या तक हिट होने तक हर बार कई पासा रोल करने के लिए रखना चाहिए ?

— हाइपरनेत्रिनो

5

हमारी प्रतिक्रिया के आधार पर अपनी चुनौती को संपादित करने के लिए समय निकालने के लिए धन्यवाद! रिकॉर्ड के लिए, हमारे पास एक जगह है जहाँ आप पोस्टिंग से पहले कुछ विवरणों को प्राप्त करने के लिए चुनौतियों का सामना कर सकते हैं: सैंडबॉक्स ।

— FryAmTheEggman

17

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

from random import*
n=2
while eval("+randrange(6)-2.5"*n):print n;n+=2

इसे ऑनलाइन आज़माएं!

चाल evalएक स्ट्रिंग की तरह योग गणना करने के लिए लग रहा है

'+randrange(6)-2.5+randrange(6)-2.5'

nअभिव्यक्त की प्रतियों के साथ । randrange(6)आउटपुट से एक यादृच्छिक संख्या [0,1,2,3,4,5]है, जिसके द्वारा नीचे स्थानांतरित कर दिया है 2.5की औसत के लिए 0। जब योग यदि 0, whileस्थिति विफल हो जाती है और लूप समाप्त हो जाता है।

map4 बाइट्स के उपयोग से एक विकल्प लंबा था:

from random import*
n=2
while sum(map(randrange,[6]*n))-2.5*n:print n;n+=2

मैं एक शून्य के लिए स्थानांतरित कर दिया मरने के लिए समान लंबाई के भाव का एक गुच्छा मिला है, लेकिन कोई भी छोटा नहीं है

randrange(6)-2.5
randint(0,5)-2.5
randrange(6)*2-5
uniform(-3,3)//1

— XNOR
स्रोत

11

मैं यह पसंद है! मुख्य रूप से क्योंकि यह केवल एक ही है जिसे मैं समझता हूं।

— जोकर

7

MATL , 13 बाइट्स

`@E6y&Yrs@7*-

इसे ऑनलाइन आज़माएं!

व्याख्या

`       % Do...while top of the stack is truthy
  @E    %   Push 2*k, where k is the iteration index starting at 1
  6     %   Push 6
  y     %   Duplicate 2*k onto the top of the stack
  &Yr   %   Array of 2*k integers distributed uniformly in {1, 2, ..., 6}
  s     %   Sum
  @7*   %   Push 7*k
  -     %   Subtract
        % End (implicit). If the top of the stack is non-zero, the loop
        % proceeds with the next iteration. Else the loop is exited.
        % Display stack (implicit)

— लुइस मेंडो
स्रोत

6

जेली , 19 14 बाइट्स

लीकी नन की मदद से -5 बाइट्स (गिनती से पुनरावृत्ति की ओर बढ़ते हुए)

‘‘6ṗX_3.L⁶S?Ṅß

न्यूलाइन द्वारा अलग किए गए परिणामों को मुद्रित करने वाला एक पूरा कार्यक्रम (एक अतिरिक्त स्थान और नईलाइन भी मुद्रित किया जाता है, और अंत में प्रोग्राम की त्रुटियां)।

इसे ऑनलाइन आज़माएं! - किसी भी समय 6 डाइस को पार कर लिया जाता है TIO इसे मेमोरी उपयोग के कारण मारता है, लेकिन यह सिद्धांत रूप में काम करता है - ऐसा करने के लिए ~ 40s लगते हैं।

एक अधिक अनुकूल 15 बाइट संस्करण जो इतने लंबे समय तक नहीं लेता है या यहां इतनी मेमोरी की आवश्यकता होती है ।

कैसे?

पुनरावर्ती रूप से 2 और पासा को तब तक रोल करता है जब तक कि प्रत्येक के 3.5 से कम चेहरों का योग शून्य न हो जाए, जैसा कि जाता है, पासा की संख्या को प्रिंट करता है, जब शून्य पर पहुंच जाता है तो यह एक प्रकार का त्रुटि पैदा करने वाले अंतरिक्ष वर्ण का उपयोग करने का प्रयास करता है।

‘‘6ṗX_3.L⁶S?Ṅß - Main link: no arguments (implicit left=zero)
‘              - increment (initial zero or the previous result)
 ‘             - increment  (= # of dice to roll, n)
  6            - literal 6
   ṗ           - Cartesian power - all possible rolls of n 6-sided dice with faces 1-6
    X          - pick one of them
      3.       - literal 3.5
     _         - subtract 3.5 from each of the roll results
           ?   - if:
          S    -          sum the adjusted roll results (will be 0 for most common)
        L      - ...then: length (number of dice that were rolled)
         ⁶     - ...else: literal ' ' (causes error when incremented in next step)
            Ṅ  - print that plus a newline
             ß - call this link with the same arity (as a monad with the result)

— जोनाथन एलन
स्रोत

वाह, यह बहुत कम बाइट्स है। बहुत बढ़िया! मैं इसे स्वीकार करने से रोक रहा हूं जब तक कि कुछ और लोग जवाब नहीं देते।

— जोकर

हाँ, यह स्वीकार करने से पहले कुछ समय इंतजार करना सामान्य है, भले ही वह ऐसा कर रहा हो। कई लोग इसे एक या दो सप्ताह देते हैं।

— जोनाथन एलन

इसके अलावा, आप सभी पुनरावृत्तियों का उत्पादन करने वाले हैं - केवल पिछले एक के लिए नहीं।

— ज़ोकेवर

ओह, मैंने एक पुराने संपादन का उत्तर दिया - जो इसे पूरी तरह से बदल देता है, मैं इस पद्धति का कई तरीकों से उपयोग नहीं कर सकता।

— जोनाथन एलन

ओह n, बस इंतज़ार करो , ठीक है शायद यह उद्धार योग्य है। मुझे लगा कि आपका मतलब है :)

— जोनाथन एलन

6

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

2→N
While mean(randInt(1,6,N)-3.5
Disp N
N+2→N
End

व्याख्या

randInt(1,6,N) 1 से 6 तक एन यादृच्छिक संख्या की एक सूची उत्पन्न करता है
mean(randInt(1,6,N)-3.5 रोल्स का औसत 3.5 से नीचे स्थानांतरित हो जाता है
While औसत अभिव्यक्ति शून्य के बराबर होने तक जारी रहती है (सबसे संभावित योग)

— andrewarchi
स्रोत

5

आर , 49 बाइट्स

n=2
while(sum(sample(6,n,T)-3.5)){print(n)
n=n+2}

sample(6,n,T)प्रतिस्थापन के साथ nसीमा से यादृच्छिक नमूने उत्पन्न करता है 1:6। प्रत्येक तत्व से 3.5 घटाना एक परिणाम देता है जिसका sum0 (फाल्सी) अगर और केवल अगर यह सबसे आम मूल्य है।

इसे ऑनलाइन आज़माएं!

विषम पासा रोल को छोड़ देता है।

— ग्यूसेप
स्रोत

यह मेरे लिए हर बार, संभव बग उत्पादन के लिए 80 लगता है?

— जोकर

@pudility आप इसे फिर से आज़माने के लिए रिक्त स्थान जोड़ सकते हैं; यह हर बार इनपुट्स / कोड स्निपेट को कैशिंग करता है

— Giuseppe

3

@Giuseppe आप सेटिंग्स के तहत TIO में कैश को अक्षम कर सकते हैं।

— xnor

जब मैंने कैश को निष्क्रिय किया तो @xnor ने कहा, यह बहुत अच्छी तरह से काम करता है। जवाब के लिए धन्यवाद!

— ज़ोकेवर

@xnor जो जानता था! भविष्य में जानकर अच्छा लगा।

— ग्यूसेप

4

जावा 8, 123 149 113 108 बाइट्स

()->{for(int n=0,s=1,i;s!=n*7;){for(i=s=++n*2;i-->0;s+=Math.random()*6);if(s!=n*7)System.out.println(n*2);}}

या 107 बाइट्स अगर हम का उपयोग एक Object nullअप्रयुक्त पैरामीटर के रूप में के बजाय।

बग-फिक्स के लिए 5: बाइट्स, टिप्पणियों में @ जूल्स द्वारा सही ढंग से बताया गया ।
-41 बाइट्स @ ओलिवरग्रेगायर की महान सोच के लिए धन्यवाद !

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

()->{                           // Method without parameter nor return-type
  for(int n=0,                  //  Amount of dice
          s=1,                  //  Sum
          i;                    //  Index
      s!=n*7;){                 //  Loop (1) as long as the sum doesn't equal `n`*7,
                                //  because we roll the dice per two, and 3.5*2=7
    for(i=s=++n*2;              //   Reset both the index and sum to `n`*2,
                                //   so we can use random 0-5, instead of 1-6
                                //   and we won't have to use `+1` at `Math.random()*6`
        i-->0;                  //   Inner loop (2) over the amount of dice
        s+=Math.random()*6      //    And increase the sum with their random results
    );                          //   End of inner loop (2)
    if(s!=n*7)                  //   If the sum doesn't equal `n`*7
      System.out.println(n*2);  //    Print the amount of dice for this iteration 
  }                             //  End of loop (1)
}                               // End of method

— केविन क्रूज़सेन
स्रोत

1

मुझे लगता है कि फ़ंक्शन में कोई त्रुटि है। यदि rबराबर है 3.5*nतो कार्यक्रम को सीधे समाप्त करना चाहिए। लेकिन, अगर मैं फ़ंक्शन को सही ढंग से समझता हूं, तो इसे nसमाप्त करने से पहले एक आखिरी बार प्रिंट किया जाएगा ।

— राजनागुल

@raznagul वास्तव में, यह एक अतिरिक्त समय नहीं छाप रहा था। हालांकि यह खराब था। इससे पहले उसने क्या किया था: यादृच्छिक 1-12 (बग 1: 2-12 होना चाहिए था); जांचें कि क्या यह 7 के बराबर है: यदि यह है: हम मुद्रण के बिना किया जाता है; यदि यह नहीं है: 2 पासा फिर से रोल करें (बग 2, 2 के बजाय 4 पासा होना चाहिए था); फिर 2 प्रिंट करें, और 2 से बढ़ाएं n। इसलिए इसमें दो बग्स थे (2-12 के बजाय 1-12; और 2 -> 2 -> 4 -> 6 -> ... जैसे 2 - के बजाय रोलिंग पासा। 4 -> 6 -> ...)। हालाँकि यह सही ढंग से प्रिंट हो रहा था, क्योंकि यह नहीं होता System.out.println(n),n+=2अगर rवास्तव में इसके बराबर होता 3.5*n।

— केविन क्रूज़सेन

2

"दो पासा को एक साथ रोल करें, 2-12 से एक यादृच्छिक संख्या उठाकर" - यह संभाव्य रूप से दो पासा को लुढ़कने के बराबर नहीं है और प्रश्न में आवश्यकतानुसार संख्याओं को जोड़ना है, इसलिए एक सही समाधान नहीं है।

— जूल्स

1

कुछ बाइट्स (113) से कम, लेकिन शायद अभी भी गोल्फ ()->{for(int n=2,s=0,e=7,i;s!=e;n+=2,e+=7){for(i=n,s=n;i-->0;)s+=Math.random()*6;if(s!=e)System.out.println(n);}}:। साथ ही, जूल्स की टिप्पणी और मेरे स्पष्टीकरण के संबंध में भी सही है। nपांसे है s, योग है e, उम्मीद है iसूचकांक है। अंत में, योग nएक +1, nसमय से बचने के लिए शुरू होता है , और s!=eदोहराया जाता है क्योंकि मुझे नहीं पता कि उस मामले से कैसे बचा जाए।

— ओलिवियर ग्रेजायर

1

मैंने इसे थोड़ा सा फिर से पकड़ लिया;)()->{for(int i=0,s=1,j;s!=i*7;){for(j=s=++i*2;j-->0;)s+=Math.random()*6;if(s!=i*7)System.out.println(i*2);}}

— ओलिवियर

3

05AB1E , 22 20 बाइट्स

-2 बाइट्स एमिग्ना के लिए धन्यवाद

[YF6L.RO}7Y*;ïQ#Y=ÌV

इसे ऑनलाइन आज़माएं!

व्याख्या

[YF6L.RO}7Y*;ïQ#Y=ÌV
[                    # Infinite loop start
 YF     }            # Y times... (Y defaults to 2)
   6L.R               # Push a random number between 1 and 6 (why does this have to be so looooong ._.)
       O              # Sum
         7Y*;ï       # Push 3.5 * Y as an int
              Q      # Is it equal to 3.5 * Y?
               #     # If so: Quit
                Y    # Push Y
                 =   # Print without popping
                  ÌV # Set Y to Y + 2

— Datboi
स्रोत

1

यदि आप के लिए कदम Oके बाद .Rआप निकाल सकते हैं )और s।

— इमीना

3

आर, 48 44 42 बाइट्स

Giuseppe के उत्तर पर 5-बाइट सुधार ।

while(sum(sample(6,F<-F+2,1)-3.5))print(F)

यह (एब) इस तथ्य का उपयोग करता है कि Fडिफ़ॉल्ट रूप से एक चर है जिसे सौंपा गया FALSEहै 0और फिर उसे बढ़ाया जा सकता है, जिससे हमें एक काउंटर चर को आरंभ करने की आवश्यकता होती है।

— rturnbull
स्रोत

1

बेशक, आप कॉल sample(6)करने के बजाय दो बाइट्स बचा सकते हैं, sample(1:6)लेकिन 44 पार कर गए अभी भी 44 है .... codegolf.stackexchange.com/a/82343/67312

— Giuseppe

@Giuseppe बेशक, धन्यवाद! मैंने अभी उत्तर संपादित किया है।

— रीटर्नबुल

2

PHP , 75 बाइट्स

for($d=2;(++$i*7/2-$r+=rand(1,6))||$i<$d;)$i%$d?:$d+=1+print"$d
".$r=$i="";

इसे ऑनलाइन आज़माएं!

— जार्ग हुल्सरमन
स्रोत

1

5^2/++$i*$d+=rand()%6लूप के लिए थोड़ी कम स्थिति है। इसके अलावा, मुझे लगता है कि वर्तमान लूप गलत तरीके से बाहर निकलता है अगर बहुत पहले "पासा" लुढ़का "1" है (यह प्रारंभिक के लिए 0 उत्पन्न करता है $d)।

— user59178

@ user59178 नाइस आइडिया लेकिन इसे जीरो एरर से डिवीजन बनाया जा सकता है इसलिए मुझे इसे संशोधित करना होगा। आप इस मामले में रुकने से पहले मेरा समाधान सही हैं जो गलत है।

— जोर्ग हल्सरमैन

आपका 45-बाइट उत्तर अमान्य है क्योंकि परिणामी वितरण प्रश्न के समान नहीं है, यहां देखें । आपका 42-बाइट उत्तर है, मुझे लगता है, गलत वितरण का भी उपयोग करना; यह उदाहरण के लिए लगता है कि दो पासा के लिए, यह राशि योग के रूप में 2 और 7 के समान है।

@Pakk हाँ 45 बाइट उत्तर अमान्य है। मुझे लगता है कि आपकी सोच झूठी है जो 42 बाइट संस्करण में होती है। विस्तृत संस्करण देखें ऑनलाइन इसे आज़माएं!

— जोर्ग हल्सरमैन

@ JörgHülsermann उस विस्तारित संस्करण की पुष्टि करता है कि मैं क्या कहता हूं। एक उचित कार्यान्वयन में, $ r / $ i का मूल्य $ i के बड़े मूल्यों के लिए 3.5 के करीब हो जाना चाहिए, लेकिन मुझे ऐसा नहीं लगता। मुझे 9984 पासा के लिए औसतन 1.16 मिला, जो कि सांख्यिकीय रूप से बेहद कम है।

1

गोल्फस्क्रिप्ट , 41 बाइट्स

0{2+.n\.[{6rand.+5-}*]{+}*!!*.}{}while;;;

इसे ऑनलाइन आज़माएं!

— लीक नन
स्रोत

1

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

For[n=1,Tr@RandomInteger[5,2n++]!=5n,Print[2n]]

LLLAMnYP से -5 बाइट्स

— J42161217
स्रोत

1

05AB1E , 17 बाइट्स

[N·ÌD6Lã.R7;-O_#,

इसे ऑनलाइन आज़माएं!

व्याख्या

[                   # loop over N in 0...
 N·Ì                # push N*2+2
    D               # duplicate
     6L             # push range [1 ... 6]
       ã            # cartesian product (combinations of N*2+2 elements in range)
        .R          # pick one at random
          7;-       # subtract 3.5 from each dice roll
             O_#    # if sum == 0 exit loop
                ,   # otherwise print the copy of N*2+2

— Emigna
स्रोत

1

बैच, 109 बाइट्स

@set/an=%1+2,s=n*5/2
@for /l %%i in (1,1,%n%)do @call set/as-=%%random%%%%%%6
@if %s% neq 0 echo %n%&%0 %n%

झुंझलाहट के बजाय, randomएक जादू पर्यावरण चर है, इसलिए यह केवल पर्यावरण के विस्तार के दौरान एक यादृच्छिक मूल्य के साथ बदल जाता है, जो आमतौर पर लूप शुरू होने से पहले होता है। callयह लूप के माध्यम से हर बार होता है, लेकिन फिर आपको %लूप से पहले विस्तार को रोकने के लिए संकेतों को दोगुना करने की आवश्यकता होती है । मज़ा शुरू होता है क्योंकि हम परिणाम को 6 से मापना चाहते हैं, जिसके लिए एक वास्तविक %संकेत की आवश्यकता होती है , जिसे अब दो बार दोगुना करना होगा। परिणाम लगातार छह है %।

— नील
स्रोत

1

जावास्क्रिप्ट (ES2015), 75 78 बाइट्स

f=(n=2)=>[...Array(n)].reduce(a=>a+Math.random()*6|0,n)==3.5*n?'':n+`
`+f(n+2)

नईनईयों द्वारा अलग किए गए परिणामों की एक स्ट्रिंग को आउटपुट करता है

संपादित करें: Shaggy के लिए एक बाइट धन्यवाद बचाया, 2 पर समारोह शुरू करने के लिए 4 बाइट्स जोड़े

व्याख्या

f=n=>
  [...Array(n)]                // Array of size n
    .reduce(                   // Combine each item
      a=>a+Math.random()*6|0,  // Add a random roll between 0 and 5 for each item
    n)                         // Start at n to correct rolls to between 1 and 6
    ==3.5*n                    // Compare total to most probable roll total
  ? ''                         // If true, end
  : n+'\n'+f(n+2)              // Otherwise, output n and continue

f=(n=2)=>[...Array(n)].reduce(a=>a+Math.random()*6|0,n)==3.5*n?'':n+`
`+f(n+2)

let roll = _ => document.getElementById('rolls').innerHTML = f();
document.getElementById('roll-button').onclick = roll;
roll();

<button id="roll-button">Roll</button>
<pre id="rolls"></pre>

स्निपेट का विस्तार करें

— andrewarchi
स्रोत

2

इसके बजाय, बैकटिक्स में संलग्न एक शाब्दिक न्यूलाइन का उपयोग करके बाइट्स सहेजें '\n'।

— झबरा

इसके साथ शुरू नहीं होता है n=2, इसके बजाय आपको फ़ंक्शन को कॉल करने पर पासा की शुरुआती संख्या निर्दिष्ट करनी होगी।

— MT0

1

php - 89 वर्ण

$r=0;$n=2;while($r!=$n*3.5){$r=$i=0;while($i<$n){$r+=rand(1,6);$i++;}print $n."
";$n+=2;}

— aslum
स्रोत

आपको इसके बजाय पहले $r=0;उपयोग की आवश्यकता नहीं है क्योंकि लूप के रूप में लिखा जा सकता है और इसके बजाय लूप के बाद में कुछ करने की अनुमति देता है या कुछ बाइट्स को बचाने से पहलेechoprint $n.""$n

— जॉर्ग ह्यूल्सरमैन

1

सी (जीसीसी) , 84 80 79 77 75 80 78 76 बाइट्स

i;f(s,j){for(;s;s?printf("%d\n",i):0)for(j=i+=2,s=i*7/2;j--;)s-=1+rand()%6;}

इसे ऑनलाइन आज़माएं!

— cleblanc
स्रोत

1

हास्केल 133 132 बाइट्स

import System.Random;import Control.Monad
s k=do n<-replicateM k$randomRIO(1,6);if sum n==7*div k 2 then pure()else do print k;s(k+2)

नीचे टिप्पणी में सुझाव के लिए @Laikoni को श्रेय।

— डेविड स्पैत्रो
स्रोत

1.) आयात को बाइट की गिनती में गिना जाना चाहिए। 2.) return()को छोटा किया जा सकता है pure()और putStrLn$showइसे छोटा किया जा सकता है print।

— लकोनी

मैं इसे तुरंत ठीक कर दूंगा। धन्यवाद

— डेविद स्पैत्रो

कुछ आगे छोटी बातों: div k 2 thenहो सकता है div k 2thenऔर do print k;s(k+2)है print k>>s(k+2)।

— लकोनी

1

ऑक्टेव 55 बाइट्स

n=2;
while mean(randi(6,n,1))-3.5!=0
n
n=n+2;
end

आंद्रेवर्ची के जवाब से प्रेरित। यदि किसी के पास कोई संकेत भी है तो उसे छोटा करें, उनका स्वागत है।

— Michthan
स्रोत

वाह, TI-BASIC और ऑक्टेव में आश्चर्यजनक रूप से समान वाक्यविन्यास हैं

— andrewarchi

@andrewarchi ऑक्टेव (ऑनलाइन संस्करण है जो मैं उपयोग करता हूं) प्रोग्रामिंग के लिए मूल बातें सिर्फ मूल बातें हैं।

— मिकथन

1

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

K2WnsmhO6K*K3.5K=+K2

इसे ऑनलाइन आज़माएं!

— QWERTZ
स्रोत

PPCG में आपका स्वागत है!

— मार्टिन एंडर

धन्यवाद! बस पायथ ट्यूटोरियल समाप्त हो गया और मुझे लगा कि मैं इसे आजमा सकता हूं, हालांकि यह अभी भी संभव नहीं है। किसी भी सुझाव की सराहना की है।

— qwertz

0

QBIC , 40 बाइट्स

{[1,r|g=g+_r1,6|]~g=r*3.5|_X\g=0?r┘r=r+2

यह बहुत स्पष्ट रूप से करता है कि चुनौती क्या पूछती है; वितरण को सही पाने का सबसे छोटा तरीका लगता है।

व्याख्या

{          DO infinitely
[1,r|      FOR a=1, a<=r (at start, r == 2), a++
g=g+       Add to g (0 at start)
  _r1,6|   a random number between 1 and 6 incl.
]          NEXT
~g=r*3.5   IF the result of all dice rolls equals the expected value
|_X        THEN quit
\g=0       ELSE, reset the dice total
?r┘        PRINT the number of dice used
r=r+2      and add 2 dice.
           END IF and LOOP are courtiously provided by QBIC at EOF.

— steenbergh
स्रोत

0

Rexx (रेजिना) , 78 बाइट्स

x=2
do forever
  t=0
  do x
    t=t+random(6)
  end
  if(t=x*3.5)then
    exit
  say x
  x=x+2
end

इसे ऑनलाइन आज़माएं!

— बम बरसाना
स्रोत

0

जावास्क्रिप्ट (ईएस 6) - 69 वर्ण

r=n=>n?r(n-1)+(Math.random()*6|0)-2.5:0;f=(n=2)=>r(n)?n+`
`+f(n+2):""

console.log(f())

स्निपेट का विस्तार करें

स्पष्टीकरण :

r=n=>                                     # Roll n dice
     n?                                   # If there is a dice left to roll
       r(n-1)                             #   Roll n-1 dice
             +(Math.random()*6|0)         #   Add a random number from 0 .. 5
                                 -2.5     #   Subtract 2.5 so sum of average is 0
                                     :0   # Else total is 0

तथा:

f=(n=2)=>                                 # Start with n = 2
         r(n)                             # Roll n dice
             ?n+"\n"+f(n+2)               # If non-zero then concatenate n, newline and
                                          #    result for n+2 dice
                           :""            # If zero (average) terminate.

— MT0
स्रोत

0

Calc2 0.7, 119 118 111 बाइट्स

using"runtime";for(n=2,d=0;d!=3.5*n;Console.WriteLine(n),n+=2)for(i=d=0;i++<n;)d+=Math.Int(Random().Next(1,7));

ungolfed:

using "runtime";
var d = 0;
var r = Random();
for(var n = 2; d != 3.5 * n; Console.WriteLine(n), n += 2)
{
    d = 0;
    for(var i = 0; i < n; i++)
        d += Math.Int(r.Next(1,7));
}

मैं गणित के बिना कर सकता था। () लेकिन दुर्भाग्य से 0.7 में रैंडम ()। अगला () फ़ंक्शन में एक बग है जहां वे सभी चींटियों के बजाय युगल लौटते हैं। इसे ठीक कर लिया गया है लेकिन इस सवाल के पोस्ट होने के बाद ही। मैं कुछ भी जीतने वाला नहीं हूं, लेकिन हे, अवधारणा का अच्छा सबूत।

संपादित करें:

"रनटाइम" (-1 बाइट) का उपयोग करने के बीच अनावश्यक स्थान को हटा दिया गया

EDIT2:

हटाए गए var r और एक नया रैंडम बनाएं जहां इसकी आवश्यकता है (-4 बाइट)
परिवर्तित i = 0, d = 0 से i = d = 0 (-2 बाइट)
चेक के बाद बढ़ा हुआ वेतन (-1 बाइट)

— hstde
स्रोत

0

रूबी , 52 बाइट्स

s=x=2;(s=0;p x.times{s+=rand(6)-2.5};x+=2)while s!=0

व्याख्या

s=x=2;                                                # sum=2, x=2
      (                                  )while s!=0  # while sum != 0:
       s=0;                                           #  reset the sum
           p                                          #  print
             x.times{              };                 #  repeat x times:
                     s+=                              #   Add to sum:
                        rand(6)                       #    random int in 0..5
                               -2.5                   #    subtract average
                                                      #  (implicitly return x for printing)
                                     x+=2             #  Increment x by 2

इसे ऑनलाइन आज़माएं!

— मूल्य स्याही
स्रोत

@P s=0लूप के सामने और उपयोग पर ध्यान दें x.times। इसका मतलब यह है कि योग हर बार रीसेट हो जाता है और फिर xपासा लुढ़का जाता है, जो सही वितरण होना चाहिए। मैं अपने कोड का स्पष्टीकरण लिखूंगा।

— वैल्यू इंक

आप सही हैं, मैं अपने निष्कर्ष के साथ बहुत तेज था।

0

जावास्क्रिप्ट, 87 वर्ण

for(n=2;eval('+'.repeat(n).replace(/./g,x=>x+(Math.random()*6|0)))!=2.5*n;n+=2)alert(n)

के console.logबजाय के साथ टेस्ट alert:

for(n=2;eval('+'.repeat(n).replace(/./g,x=>x+(Math.random()*6|0)))!=2.5*n;n+=2)console.log(n)
console.log('Done')

स्निपेट का विस्तार करें

— Qwertiy
स्रोत

0

लुआ, 102 बाइट्स

function r(n,t) for d=1,n do t=t+math.random(1,6)end return t==n*3.5 or print(n)or r(n+2,0)end r(2,0)

या अधिक पठनीय संस्करण

function r(n,t) --recursive function does its magic, t is given to safe usage bytes(no local)
    for d=1,n do --roll n dice and count them up to the total (t)
         t =t+math.random(1,6)
    end 
    return t==n*3.5 or --check if t==n*3.5. If it is then it ends
           print(n) or --t != n*3.5 thus print n. print returns nil
           r(n+2,0) --both the check and the return value from print are false thus r gets executed.
end 
r(2,0) --start the process

96 बाइट्स के लिए एक अधिक चीटी संस्करण

function r(n,t,m)t=t+m(1,6)+m(1,6)return t==n*3.5 or print(n)or r(n+2,t,m)end r(2,0,math.random)

यह बहुत पहले के रूप में ही काम करता है, लेकिन पहले के कॉल से रोल का पुन: उपयोग करता है। इस वजह से मैं लूप के लिए निकाल सकता हूं। दोनों का लुआ 5.2 में परीक्षण किया जाता है

— lenscas
स्रोत

0

पर्ल 6 , 48 बाइट्स

.say for 2,*+2...^{3.5*$_==sum (1..6).pick xx$_}

— शॉन
स्रोत

-1

PHP, 51 बाइट्स

$r=2;$n=2;while(rand(0,6)-2.5*$r){print $n;$n=$n+2;}

— शिव
स्रोत

यदि आपका आउटपुट हमेशा 2 है, तो यह एक मान्य उत्तर नहीं है ...

अगर हम लूप करते समय $ n को अंदर प्रिंट करते हैं, तो यह निम्नलिखित प्रिंट करेगा: 2,4,6,8,10 .....

— शिव

2

फिर भी, मैं यह नहीं देखता कि यह प्रश्न में आवश्यकताओं का पालन कैसे करता है। आप दो चर का उपयोग करते हैं: "$ n" और "n"। "n" अपरिभाषित है, इसलिए इसे शून्य पर सेट किया जाएगा। इतनी प्रभावी रूप से, आप जो करते हैं वह एक सम संख्या का प्रिंट होता है, और अगले सम संख्या को प्रिंट करने का 5/6 का मौका होता है। यह गणितीय रूप से प्रश्न में वितरण के बराबर नहीं है।

टाइपो, वह एन हमेशा 2 होना चाहिए, कोड को अपडेट किया।

— शिव

अभी भी नहीं कि सवाल क्या पूछता है ... अब आप एक डाई फेंक रहे हैं, जांचें कि क्या यह पांच (= 2 * 2.5) है; यदि मरना पाँच है, तो आप रुक जाते हैं, और यदि यह पाँच नहीं है, तो आप अगला नंबर भी लिखते हैं और जारी रखते हैं। गणितीय रूप से प्रभावी रूप से वही है जो आपने कोड के पिछले संस्करण में किया था।

सबसे संभावित संख्या को रोल किए बिना आप कितने पासा रोल कर सकते हैं

संकट

उदाहरण रन

नियम

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

MATL , 13 बाइट्स

व्याख्या

जेली , 19 14 बाइट्स

कैसे?

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

आर , 49 बाइट्स

जावा 8, 123 149 113 108 बाइट्स

05AB1E , 22 20 बाइट्स

व्याख्या

आर, 48 44 42 बाइट्स

PHP , 75 बाइट्स

गोल्फस्क्रिप्ट , 41 बाइट्स

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

05AB1E , 17 बाइट्स

बैच, 109 बाइट्स

जावास्क्रिप्ट (ES2015), 75 78 बाइट्स

php - 89 वर्ण

सी (जीसीसी) , 84 80 79 77 75 80 78 76 बाइट्स

हास्केल 133 132 बाइट्स

ऑक्टेव 55 बाइट्स

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

QBIC , 40 बाइट्स

व्याख्या

Rexx (रेजिना) , 78 बाइट्स

जावास्क्रिप्ट (ईएस 6) - 69 वर्ण

Calc2 0.7, 119 118 111 बाइट्स

रूबी , 52 बाइट्स

व्याख्या

जावास्क्रिप्ट, 87 वर्ण

लुआ, 102 बाइट्स

पर्ल 6 , 48 बाइट्स

PHP, 51 बाइट्स