कार्ड जोड़ी संभावना

9

कुल एन * एम कार्डों के लिए पूर्णांक मानों [ 1 , M ] के साथ कार्ड की एन प्रतियों से युक्त एक डेक को देखते हुए , इस संभावना की गणना करें कि 1 के मान वाला कार्ड 2 के मान वाले कार्ड के समीप है ।

आपका समाधान सटीक या सन्निकट हो सकता है, और इसे प्रत्येक इनपुट के लिए समान चलाने के लिए समान होने की आवश्यकता नहीं है। दिए गए उत्तर को वास्तविक समाधान के +/- 5% के भीतर होना चाहिए (वास्तव में दुर्लभ संभावनाएं कि आरएनजी आपके पक्ष में नहीं है)। आपके कार्यक्रम को उचित समय में जवाब देना चाहिए (कहते हैं, आपके पास जो भी हार्डवेयर है उस पर 10 मिनट से कम समय)। आप मान सकते हैं कि M और N उचित छोटे हैं और त्रुटि जाँच की आवश्यकता नहीं है।

डेक चक्रीय नहीं है , इसलिए यदि पहला कार्ड 1 है और अंतिम कार्ड 2 है , तो यह आसन्न आवश्यकताओं को पूरा नहीं करता है।

एक परीक्षण मामले के रूप में, एन = 4 और एम = 13 (एक मानक 52-कार्ड डेक) के लिए अपेक्षित समाधान ~ 48.6% है।

रैंडम फेरबदल का उपयोग करके पायथन + न्यूमपी में गैर-गोल्फ कार्यान्वयन एक उदाहरण है:

from __future__ import division
from numpy import *

def adjacent(N, M):
    deck = array([i for i in range(1, M+1)]*N)
    trials = 100000
    count = 0
    for i in range(trials):
        random.shuffle(deck)
        ores = (deck == 1)
        tres = (deck == 2)
        if(any(logical_and(ores[1:], tres[:-1])) or
           any(logical_and(ores[:-1], tres[1:]))):
            count += 1
    return count/trials

आउटपुट आपके द्वारा सुविधाजनक (फ़ंक्शन रिटर्न मान, टर्मिनल आउटपुट, फ़ाइल, आदि) खोजने के लिए किसी भी रूप में हो सकता है, और इनपुट किसी भी रूप में आपको सुविधाजनक (फ़ंक्शन पैरामीटर, टर्मिनल इनपुट, कमांड लाइन arg, आदि) मिल सकता है।

मानक लूप-होल लागू होते हैं।

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

लीडरबोर्ड

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

code-golf  probability-theory  simulation 
— helloworld922
स्रोत
1
आस-पास नहीं लपेटना एक भ्रामक जटिल मोड़ है
— शुक्राणु
@Srr आपने मुझे एक विचार दिया! :-)
— लुइस मेंडो

जवाबों:

2

पायथ, 23 22 बाइट्स

csm}1sM.:.S*vzUQ2J^T4J

10000 पुनरावृत्तियों चलाता है। नंबर को बाइट की लागत पर बदला जा सकता है। इनपुट नईलाइन अलग है। मेरे कंप्यूटर पर लगभग 9 सेकंड लगते हैं।

प्रदर्शन

csm}1sM.:.S*vzUQ2J^T4J
                 J^T4     J = 10000
  m              J        Do the following J times.
           *vzUQ          Set up the deck. (0 .. n-1, repeated m times.)
         .S               Shuffle the deck.
       .:       2         Find all 2 elment substrings.
     sM                   Add them up.
   }1                     Check if any pairs add to 1 ([0, 1] or [1, 0])
 s                        Add up the results (True = 1, False = 0)
c                     J   Divide by J.
— isaacg
स्रोत
2

MATL , 44 46 बाइट्स

यह भाषा का रिलीज 3.1.0 का उपयोग करता है , जो इस चुनौती से पहले है।

गणना एक लूप के साथ की जाती है जो 1000 यादृच्छिक वास्तविकताओं को आकर्षित करती है। इसे चलाने में कुछ सेकंड लगते हैं। यह एक सदिश तरीके से तेजी से किया जा सकता है। इनपुट फॉर्म का है [N M]।

पुराना संस्करण : कार्ड का एक यादृच्छिक डेक बनाता है और इसे दो बार जांचता है: पहले आगे और फिर पीछे की दिशा में।

itpw1)1e3:"2$twZ@w/Y]t1HhXfnwH1hXfn|bb]xxN$hYm

नया संस्करण : कार्ड का एक यादृच्छिक डेक उत्पन्न करता है और फिर 0बीच में एक के साथ इसके फ़्लिप किए गए संस्करण को जोड़ता है । इस तरह से जाँच केवल एक बार, आगे की दिशा में की जा सकती है। इससे दो बाइट बचती हैं।

itpw1)1e3:"2$twZ@w/Y]tP0whh1HhXfngbb]xxN$hYm

उदाहरण

>> matl itpw1)1e3:"2$twZ@w/Y]tP0whh1HhXfngbb]xxN$hYm
> [4 13]
0.469

व्याख्या

i                 % input: [N M]
tpw1)             % produce N*M and N
1e3:"             % repeat 1000 times
  2$twZ@w/Y]      % produce random deck of cards from 1 to N*M
  tP0whh          % append 0 and then flipped version of deck
  1Hh             % vector [1 2]
  Xf              % find one string/vector within another                          
  ng              % was it found at least once?
  bb              % bubble up element in stack, twice                     
]                 % end                                                     
xx                % delete top of the stack, twice
N$h               % vector with all elements in stack
Ym                % mean value
— लुइस मेंडो
स्रोत
1

पायथ, 16 बाइट्स

JE?>J1-1^-1c2JQZ

प्रदर्शन।

यह इस प्रकार है

  • एक शिक्षित अनुमान लगाएं,
  • जाँच लें कि यह काफी करीब है,
  • दोहराना

प्रोग्रामिंग की रणनीति। इस मामले में जीतने वाला शिक्षित अनुमान है

1 - (1 - 2 / M) ** N

जो मोटे तौर पर कहता है कि Nबाल्टी में गिरने की संभावना है, और वैध बाल्टी का कुछ अंश है 2 / M। बाल्टियाँ 0s के बगल में स्थित होती हैं , और संभावनाएं 1s होती हैं।

त्रुटि कभी भी 3% (आश्चर्यजनक रूप से) से ऊपर नहीं जाती है, और 0% में परिवर्तित होने लगती है क्योंकि पैरामीटर बड़े हो जाते हैं (जैसा कि मुझे उम्मीद होगी)।

इनपुट नईलाइन अलग है।

              Q  Q = eval(input())
JE               J = eval(input())
  ?>J1           if J > 1
      -1^-1c2JQ  then 1 - (1 - 2 / J) ** Q
               Z else 0

आप एक चरित्र को बचा सकते हैं यदि आप स्पष्ट रूप से स्पष्ट तथ्य को स्वीकार करते हैं False == 0, और इसके JE&>J1-1^-1c2JQबजाय करते हैं।

— Veedrac
स्रोत
यह मेरी पहली पाइथ (और मेरा पहला उत्तर) पर होता है, इसलिए आलोचना और मदद का विशेष रूप से स्वागत है।
— विड्रैक
1

MATL , 44 38 बाइट्स

यह भी MATL संस्करण 3.1.0 का उपयोग करता है , जो इस चुनौती से पहले है।

नया संस्करण, 4 बाइट बचाने के लिए लुइस मेंडो के लिए धन्यवाद!

iiXI*XJxO1e4XH:"JZ@I\TTo3X53$X+1=a+]H/

पुराना संस्करण (44 बाइट्स):

OiitXIx*XJx1e4XH:"JJZrI\[1 1]3X5,3$X+1=a+]H/

व्याख्या

i               % take input for N
i               % take input for M
XI              % save M into clipboard I
*XJ             % multiply N and M and store in clipboard J
x               % clear the stack
O               % make a zero to initialise count of pairs
1e4XH:"         % 1e4=10000, XH saves into clipboard H, : makes the vector 1:1e4
                % which is used to index a for loop, started using "
    JZ@         % Use randperm to generate a random permutation of the vector 1:N*M
    I\          % take the result mod M, now each card has a value one less than before
    TTo3X53$X+  % convolve vector of card values with [1 1] to do pairwise summation
    1=a         % find if any sums equal 1, which means there is a [0 1] or [1 0]         
    +           % add the logical value to the count of pairs
]
H/              % divide the count by the number of deals to get the probability

उदाहरण के लिए,

>> matl 'iiXI*XJxO1e4XH:"JZ@I\TTo3X53$X+1=a+]H/'
> 4
> 13
0.4861

नोट (21/5/16): MATL रिलीज़ 18.0.0 के रूप में, X+हटा दिया गया है, लेकिन Y+इसका उपयोग इसके स्थान पर किया जा सकता है। 18.0.0 मतलब करने के लिए Matl संस्करण 3.1.0 से परिवर्तन है कि इस सवाल का जवाब अब सिर्फ 31 बाइट्स में लिखा जा सकता है, *xO1e4:"2:Gtb*Z@w\TT2&Y+1=ah]Ym।

— डेविड
स्रोत
मुझे पता है कि पहले से ही एक MATL उत्तर है, लेकिन मुझे लगता है कि विधियां काफी भिन्न हैं इसलिए मैंने अभी भी इसे पोस्ट किया है।
— डेविड
मुझे यकीन है!
— लुइस मेंडू
आप एक छोटे से बदल रहा है बचा सकता है [1 1]में TTo। इसके अलावा, आपको अल्पविराम की आवश्यकता नहीं है
— लुइस मेंडो
@LuisMendo धन्यवाद! मैंने सोचा कि ऐसा करने का एक बेहतर तरीका रहा होगा!
— डेविड
अब मैं देखता हूं कि यहां कैसे कन्विक्शन काम करता है। 0-कार्ड के नामकरण का उपयोग करना बहुत ही चतुर था!
— लुइस मेंडू
0

गणितज्ञ, 93 92 91 बाइट्स

N@Count[RandomSample@Flatten[Range@#~Table~{#2}]~Table~{a=1*^5},{b=___,1,2,b}|{b,2,1,b}]/a&

फिर भी बंद रूप की तलाश ...

— LegionMammal978
स्रोत
यह क्रमपरिवर्तन गणनाओं के एक नेस्टेड लूप को शामिल करने जा रहा है।
— Sparr
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.