समस्या का विवरण

पोलिया अपने कलश के साथ फिर से खेल रही है और वह चाहती है कि आप कुछ संभावनाओं की गणना करने में उसकी मदद करें।

इस कलश प्रयोग में पोल्लिया में एक कलश होता है जिसमें शुरू में 1 लाल और 1 नीला मनका होता है।

प्रत्येक पुनरावृत्ति के लिए, वह अंदर पहुंचता है और एक मनका को प्राप्त करता है, फिर रंग का निरीक्षण करता है और मनके को कलश में वापस रखता है।

उसके बाद वह एक निष्पक्ष सिक्के को फड़फड़ाता है, यदि सिक्का भूमि के सिर को वह एक ही रंग के मनके 6 मेले की रोल रोल राशि डाल देगा, यदि यह भूमि को पूंछता है तो वह कलश से उसी रंग के मनके की आधी संख्या निकाल देगा ( पूर्णांक विभाजन का उपयोग करना - इसलिए यदि चयनित रंग के मोतियों की संख्या विषम है तो वह निकाल देगा (c-1)/2जहां c उस रंग के मोतियों की संख्या है)

एक पूर्णांक n and 0 और एक दशमलव r> 0 को देखते हुए, 2 दशमलव स्थानों को संभावना दें कि n पुनरावृत्तियों के बाद मोतियों के रंगों के बीच अनुपात बाइट्स में r की तुलना में अधिक या बराबर है।

पुनरावृत्तियों का एक उदाहरण सेट:

आइए (x, y) कलश को ऐसे परिभाषित करें कि उसमें x लाल मोती और y नीले मोती हों।

Iteration    Urn       Ratio
0            (1,1)     1
1            (5,1)     5        //Red bead retrieved, coin flip heads, die roll 4
2            (5,1)     5        //Blue bead retrieved, coin flip tails
3            (3,1)     3        //Red bead retrieved, coin flip tails
4            (3,4)     1.333... //Blue bead retrieved, coin flip heads, die roll 3

जैसा कि देखा जा सकता है कि अनुपात r हमेशा so 1 होता है (इसलिए यह लाल या नीले रंग से अधिक होता है जो कि कम भाग से विभाजित होता है)

परीक्षण के मामलों:

बता दें कि एफ पुनरावृत्तियों के लिए फ़ंक्शन का अनुप्रयोग परिभाषित करता है

F(0,5) = 0.00
F(1,2) = 0.50
F(1,3) = 0.42
F(5,5) = 0.28
F(10,4) = 0.31
F(40,6.25) = 0.14

यह कोड गोल्फ है, इसलिए बाइट्स जीत में सबसे छोटा समाधान है।

code-golf probability-theory

— समय सीमा समाप्त डेटा
स्रोत

मुझे ऐसा लगता है कि इसके लिए एक सूत्र है ...

— अज्ञानता का प्रतीक

बीटा बिनोमाइल्स के साथ करने के लिए कुछ हो सकता है, लेकिन इसे लिखने में अधिक समय लग सकता है

— एक्सपायर डेटा

भाषा पर निर्भर करता है; आर और गणितज्ञ इसे कुशलता से करने में सक्षम हो सकते हैं।

— ग्यूसेप

6

जावास्क्रिप्ट (ईएस 7), 145 ... 129 124 123 बाइट्स

के रूप में इनपुट लेता है (r)(n)। यह एक भोला समाधान है जो वास्तव में संपूर्ण अनुकरण करता है।

r=>g=(n,B=s=0,R=0,h=d=>++d<7?h(d,[0,d].map(b=>g(n,B/-~!!b,R/-~!b)&g(n,B+b,R+d-b))):s/24**-~n)=>n--?h``:s+=~B<=r*~R|~R<=r*~B

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

पिछले 2 परीक्षण मामलों के लिए बहुत धीमा।

टिप्पणी की गई

r =>                    // r = target ratio
g = (                   // g is a recursive function taking:
  n,                    //   n = number of iterations
  B =                   //   B = number of blue beads, minus 1
  s = 0,                //   s = number of times the target ratio was reached
  R = 0,                //   R = number of red beads, minus 1
  h = d =>              //   h = recursive function taking d = 6-sided die value
    ++d < 7 ?           // increment d; if d is less than or equal to 6:
      h(                //   do a recursive call to h:
        d,              //     using the new value of d
        [0, d].map(b => //     for b = 0 and b = d:
          g(            //       do a first recursive call to g:
            n,          //         leave n unchanged
            B / -~!!b,  //         divide B by 2 if b is not equal to 0
            R / -~!b    //         divide R by 2 if b is equal to 0
          ) & g(        //       do a second recursive call to g:
            n,          //         leave n unchanged
            B + b,      //         add b blue beads
            R + d - b   //         add d - b red beads
          )             //       end of recursive calls to g
        )               //     end of map()
      )                 //   end of recursive call to h
    :                   // else (d > 6):
      s / 24 ** -~n     //   stop recursion and return s / (24 ** (n + 1))
) =>                    // body of g:
  n-- ?                 //   decrement n; if n was not equal to 0:
    h``                 //     invoke h with d = [''] (coerced to 0)
  :                     //   else:
    s +=                //     increment s if:
      ~B <= r * ~R |    //       either (-B-1) <= r*(-R-1), i.e. (B+1)/(R+1) >= r
      ~R <= r * ~B      //       or     (-R-1) <= r*(-B-1), i.e. (R+1)/(B+1) >= r

— Arnauld
स्रोत

मुझे वास्तव में यह उत्तर पसंद है, मैंने पाया कि बाद के परीक्षण मामलों को हल करने के लिए मुझे समान अनुपात की संभावनाओं को मर्ज करने के लिए कोड जोड़ने की आवश्यकता थी। इसलिए मुझे आश्चर्य नहीं है कि यह बहुत धीमा है

— डेटा

0

वोल्फ्राम भाषा (गणितज्ञ) , 133 बाइट्स

Length@Select[#2/#&@@@(r=Nest[Sort/@Flatten[Table[{{k,0}+#,⌈#/{1,2}⌉},{k,6}]&/@Join[#,Reverse/@#],2]&,{{1,1}},x]),#>=y&]/Length@r

उपयोग करके N[F,2], आउटपुट को 2 दशमलव अंकों को प्रिंट करना चाहिए लेकिन TIO प्रिंट अधिक ...