अपेक्षित संख्या मैं तब तक आरेखण कार्ड के बाद रहूंगा जब तक कि मुझे एक इक्का, 2, 3 और आगे नहीं मिलता

Question

मुझे निम्नलिखित को हल करने में कुछ परेशानी हो रही है।

आप एक मानक 52-कार्ड डेक से प्रतिस्थापन के बिना कार्ड खींचते हैं जब तक आपको एक इक्का नहीं मिलता। आप तब तक ड्रॉ करते हैं, जब तक आप एक 2. प्राप्त नहीं कर लेते हैं। आप 3 पर जारी रखते हैं। 3. पूरे डेक के रन आउट होने के बाद आप अपेक्षित संख्या क्या है?

ऐसा होना स्वाभाविक था

• $T_i = \text{first position of card whose value is }i$
• $U_i = \text{last position of card whose value is }i$

इसलिए समस्या अनिवार्य रूप से इस संभावना का पता लगाने के लिए है कि आप डेक के बाहर होने पर पर होंगे , अर्थात्:$k$

$$Pr(T_1<\cdots<T_k \cap U_{k+1} < T_k)$$

मैं देख सकता हु

$$Pr(T_1<\cdots<T_k) = 1/k! \\ \text{and} \\ Pr(U_{k+1} < T_k) = 1/70$$

लेकिन आगे कोई नहीं मिल सका ...

Comments

यदि आप पहले ही सभी एस खींच चुके हैं तो क्या होगा जब आप अपना पहला ऐस ड्रा करेंगे? $2$

— गंग - मोनिका

क्या "अपेक्षित" संख्या वास्तव में "सबसे अधिक संभावना" संख्या है?

— whuber

यह एक दिलचस्प समस्या है, लेकिन मैं उन गणित के बारे में निश्चित नहीं हूं जो आप लिखते हैं कि "समस्या अनिवार्य रूप से मात्रा में है"। पहले बयान में क्या आप का मतलब बजाय लिखना है ? फिर भी, हालांकि, मुझे यकीन नहीं है कि बयान सही है। एक शुरुआत पर विचार करें । हमारे पास और इसलिए , लेकिन अगर मैं आपके पाठ विवरण को ठीक से तो हम अभी भी ऐस को दूसरे स्थान पर और फिर 2 को पांचवें स्थान पर उठा सकते हैं? और इसलिए एक आवश्यक शर्त नहीं है? ∪ टी 1 = 2 , टी 2 = 1 टी 1 > टी 2 टी 1 < टी $\cap$$\cup$2AAA2$T_1=2, T_2=1$$T_1 > T_2$$T_1 < T_2$

— टीओटी

@TooTone ओह, मैं मतलब की तरह आप ने कहा, और आप सही कर रहे हैं; एक आवश्यक शर्त नहीं है ...टी 1 < टी $\cap$$T_1 < T_2$

— बिल

@ गुंग उस स्थिति में, आपका डेक बाहर चला जाएगा और आप अभी भी 2 पर रहेंगे।

— बिल

Answer 1

@ गंग के विचार के बाद, मेरा मानना ​​है कि अपेक्षित मूल्य 5.84 होगा? और टिप्पणियों की मेरी व्याख्या से, मुझे लगता है कि "ए" एक लगभग असंभव मूल्य है (जब तक कि डेक में अंतिम चार कार्ड सभी इक्के नहीं हैं)। यहाँ एक 100,000 पुनरावृत्ति मोंटे कार्लो सिमुलेशन के परिणाम हैं

results
    2     3     4     5     6     7     8     9     J     K     Q     T 
 1406  7740 16309 21241 19998 15127  9393  4906   976   190   380  2334 

और यदि आप इसके साथ खेलना चाहते हैं तो यहां आर कोड है ..

# monte carlo card-drawing functions from here
# http://streaming.stat.iastate.edu/workshops/r-intro/lectures/5-Rprogramming.pdf

# create a straightforward deck of cards
create_deck <-
    function( ){
        suit <- c( "H" , "C" , "D" , "S" )
        rank <- c( "A" , 2:9 , "T" , "J" , "Q" , "K" )
        deck <- NULL
        for ( r in rank ) deck <- c( deck , paste( r , suit ) )
        deck
    }

# construct a function to shuffle everything
shuffle <- function( deck ){ sample( deck , length( deck ) ) }

# draw one card at a time
draw_cards <-
    function( deck , start , n = 1 ){
        cards <- NULL

        for ( i in start:( start + n - 1 ) ){
            if ( i <= length( deck ) ){
                cards <- c( cards , deck[ i ] )
            }
        }

        return( cards )
    }

# create an empty vector for your results
results <- NULL

# run your simulation this many times..
for ( i in seq( 100000 ) ){
    # create a new deck
    sdeck <- shuffle( create_deck() )

    d <- sdeck[ grep('A|2' , sdeck ) ]
    e <- identical( grep( "2" , d ) , 1:4 )

    # loop through ranks in this order
    rank <- c( "A" , 2:9 , "T" , "J" , "Q" , "K" )

    # start at this position
    card.position <- 0

    # start with a blank current.draw
    current.draw <- ""

    # start with a blank current rank
    this.rank <- NULL

    # start with the first rank
    rank.position <- 1

    # keep drawing until you find the rank you wanted
    while( card.position < 52 ){

        # increase the position by one every time
        card.position <- card.position + 1

        # store the current draw for testing next time
        current.draw <- draw_cards( sdeck , card.position )

        # if you draw the current rank, move to the next.
        if ( grepl( rank[ rank.position ] , current.draw ) ) rank.position <- rank.position + 1

        # if you have gone through every rank and are still not out of cards,
        # should it still be a king?  this assumes yes.
        if ( rank.position == length( rank ) ) break        

    }

    # store the rank for this iteration.
    this.rank <- rank[ rank.position ]

    # at the end of the iteration, store the result
    results <- c( results , this.rank )

}

# print the final results
table( results )

# make A, T, J, Q, K numerics
results[ results == 'A' ] <- 1
results[ results == 'T' ] <- 10
results[ results == 'J' ] <- 11
results[ results == 'Q' ] <- 12
results[ results == 'K' ] <- 13
results <- as.numeric( results )

# and here's your expected value after 100,000 simulations.
mean( results )

Comments

क्यों Aअसंभव है? AAAAउदाहरण के लिए 48 कार्ड के अनुक्रम पर विचार करें ।

— टीओटी

आप सही हैं .. यह 270725 में से एक है - या आर कोड के साथ1/prod( 48:1 / 52:5 )

— एंथनी

यह उत्तर गलत है। "2" के लिए गणना पर विचार करें: क्योंकि इसका परिणाम केवल तब हो सकता है जब सभी 2 में से किसी 1 के पहले सामना किया जाता है, इसकी संभावना हर और इसलिए आपके सिमुलेशन में इसकी उम्मीद की मानक त्रुटि के साथ । आपका का आउटपुट छह मानक त्रुटियों से अधिक है, जिससे यह लगभग निश्चित रूप से त्रुटिपूर्ण है। माध्य के लिए एक सटीक मान ( पुनरावृत्तियों के साथ एक अलग सिमुलेशन पर आधारित ) । $\binom{8}{4}=70$37.516601065.833±$10^5/\binom{8}{4}\approx 1428.6$$37.5$$1660$$10^6$$5.833\pm 0.004$

— whuber

दुर्भाग्यवश आपका भारी-भरकम डॉक्यूमेंट कोड कई बार लंबा और धीमा होता है। मैंने दिखाया कि इसका आउटपुट गलत है; हालांकि मैं चाहता हूं कि मेरे पास आपके कोड को डिबग करने का समय हो और मैं ऐसा नहीं करना चाहता। मेरा तर्क यह है: आप अभी भी "2" पर काम कर रहे होंगे, अगर केवल और केवल "2" सभी "ए" के पहले हों। चार "2" और चार "ए" की व्यवस्था करने के लिए समान रूप से संभावित तरीके से बीच, उनमें से एक बिल्कुल इस मानदंड को संतुष्ट करता है। इसलिए शीर्षक "2" के अंतर्गत आपका मान करीब होना चाहिए , लेकिन ऐसा नहीं है। 105/70=$\binom{4+4}{4}=70$results$10^5/70=1429$

— whuber

यहां तक ​​कि मध्यस्थ अन्य लोगों के वोटों को हटा नहीं सकते हैं :-)। एक ची-स्क्वेर्ड परीक्षण अब आपके परिणामों को खदान से सहमत होने का सुझाव देता है, लेकिन यह जानना अच्छा होगा कि आपने अपने सिमुलेशन का परीक्षण कैसे किया, क्योंकि इससे आपके उत्तर में आत्मविश्वास में सुधार होगा। वास्तव में, आपके द्वारा अपने उत्तर में पहले पैराग्राफ में किए गए एक संपादन के अनुसार, अब हमारे दोनों परिणाम गलत हैं: जैसा कि मैंने आपके प्रश्न की व्याख्या की है, यह तब भी संभव नहीं है जब सभी कार्ड समाप्त हो जाने पर इक्का पर काम कर रहे हों।

— whuber

Answer 2

एक सिमुलेशन के लिए यह सही होने के साथ-साथ तेज़ होना महत्वपूर्ण है । इन दोनों उद्देश्यों से कोड लिखने का सुझाव मिलता है जो प्रोग्रामिंग वातावरण की मुख्य क्षमताओं के साथ-साथ उस कोड को भी लक्षित करता है जो यथासंभव छोटा और सरल है, क्योंकि सादगी स्पष्टता प्रदान करती है और स्पष्टता शुद्धता को बढ़ावा देती है। यहाँ दोनों को प्राप्त करने का मेरा प्रयास है R:

#
# Simulate one play with a deck of `n` distinct cards in `k` suits.
#
sim <- function(n=13, k=4) {
  deck <- sample(rep(1:n, k)) # Shuffle the deck
  deck <- c(deck, 1:n)        # Add sentinels to terminate the loop
  k <- 0                      # Count the cards searched for
  for (j in 1:n) {
    k <- k+1                          # Count this card
    deck <- deck[-(1:match(j, deck))] # Deal cards until `j` is found
    if (length(deck) < n) break       # Stop when sentinels are reached
  }
  return(k)                   # Return the number of cards searched
}

यादृच्छिक संख्या के बीज को सेट करने के बाद इसे एक प्रतिलिपि प्रस्तुत करने योग्य तरीके से लागू किया जा सकता हैreplicate

> set.seed(17);  system.time(d <- replicate(10^5, sim(13, 4)))
   user  system elapsed 
   5.46    0.00    5.46

यह धीमी है, लेकिन काफी तेजी से काफी लंबा (और इसलिए सटीक) सिमुलेशन का इंतजार किए बिना बार-बार आचरण करने के लिए पर्याप्त है। परिणाम प्रदर्शित करने के कई तरीके हैं। आइए इसके माध्यम से शुरू करते हैं:

> n <- length(d)
> mean(d)
[1] 5.83488

> sd(d) / sqrt(n)
[1] 0.005978956

उत्तरार्द्ध मानक त्रुटि है: हम उम्मीद करते हैं कि नकली का मतलब सही मूल्य के दो या तीन एसई के भीतर हो। यह सही उम्मीद और बीच$5.817$$5.853$ ।

हम आवृत्तियों (और उनकी मानक त्रुटियों) का सारणीकरण भी देखना चाहते हैं। निम्न कोड सारणीयन को थोड़ा छोटा करता है:

u <- table(d)
u.se <- sqrt(u/n * (1-u/n)) / sqrt(n)
cards <- c("A", "2", "3", "4", "5", "6", "7", "8", "9", "T", "J", "Q", "K")
dimnames(u) <- list(sapply(dimnames(u), function(x) cards[as.integer(x)]))
print(rbind(frequency=u/n, SE=u.se), digits=2)

यहाँ उत्पादन है:

                2       3      4      5      6      7       8       9       T       J       Q       K
frequency 0.01453 0.07795 0.1637 0.2104 0.1995 0.1509 0.09534 0.04995 0.02249 0.01009 0.00345 0.00173
SE        0.00038 0.00085 0.0012 0.0013 0.0013 0.0011 0.00093 0.00069 0.00047 0.00032 0.00019 0.00013

---

हम कैसे जान सकते हैं कि अनुकरण भी सही है? एक तरीका यह है कि छोटी-छोटी समस्याओं के लिए इसका परीक्षण किया जाए। उस कारण से इस कोड को समस्या के एक छोटे से सामान्यीकरण पर हमला करने के लिए लिखा गया था, जिसमें अलग-अलग कार्डों की जगह थी और सूट थे । हालांकि, परीक्षण के लिए एक पूर्वनिर्धारित क्रम में कोड को डेक खिलाने में सक्षम होना महत्वपूर्ण है। आइए एक ही एल्गोरिदम पर थोड़ा अलग इंटरफ़ेस लिखें:$13$n$4$k

draw <- function(deck) {
  n <- length(sentinels <- sort(unique(deck)))
  deck <- c(deck, sentinels)
  k <- 0
  for (j in sentinels) {
    k <- k+1
    deck <- deck[-(1:match(j, deck))]
    if (length(deck) < n) break
  }
  return(k)
}

( हर drawजगह के स्थान पर इसका उपयोग करना संभव simहै, लेकिन शुरुआत में किया गया अतिरिक्त कार्य drawइसे दोगुना धीमा करता है sim।)

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

n <- 4 # Distinct cards
k <- 2 # Number of suits
d <- expand.grid(lapply(1:(n*k), function(i) 1:n))
e <- apply(d, 1, function(x) var(tabulate(x))==0)
g <- apply(d, 1, function(x) length(unique(x))==n)
d <- d[e & g,]

अब dएक डेटा फ्रेम है जिसकी पंक्तियों में सभी फेरबदल हैं। drawप्रत्येक पंक्ति पर लागू करें और परिणाम गिनें:

d$result <- apply(as.matrix(d), 1, draw)
    (counts <- table(d$result))

आउटपुट (जिसे हम एक औपचारिक परीक्षण में क्षण भर में उपयोग करेंगे) है

   2    3    4 
 420  784 1316 

( मूल्य को समझना आसान है, वैसे: हम अभी भी कार्ड पर काम कर रहे हैं यदि और केवल अगर सभी दो पूर्ववर्ती सभी इक्के हैं। ऐसा होने की संभावना है (दो सूट के साथ) । अलग-अलग फेरबदल में से, में यह संपत्ति है।)2 1 / ( 2 + $420$$2$25202520/6=$1/\binom{2+2}{2} = 1/6$$2520$$2520/6 = 420$

हम आउटपुट को ची-स्क्वेर्ड टेस्ट के साथ टेस्ट कर सकते हैं। अंत में मैं अलग कार्ड के इस मामले में सूट में गुना लागू करता हूं :sim एन = 4 के = $10,000$$n = 4$$k = 2$

>set.seed(17)
>d.sim <- replicate(10^4, sim(n, k))
>print((rbind(table(d.sim) / length(d.sim), counts / dim(d)[1])), digits=3)

         2     3     4
[1,] 0.168 0.312 0.520
[2,] 0.167 0.311 0.522

> chisq.test(table(d.sim), p=counts / dim(d)[1])

    Chi-squared test for given probabilities

data:  table(d.sim) 
X-squared = 0.2129, df = 2, p-value = 0.899

चूँकि इतना ऊँचा है, हम जो कहते हैं और जो व्यापक गणना द्वारा गणना मूल्यों के बीच कोई महत्वपूर्ण अंतर नहीं है । और के कुछ अन्य (छोटे) मूल्यों के लिए इस अभ्यास को दोहराना तुलनात्मक परिणाम देता है, जिससे हमें और लागू होने पर विश्वास करने का पर्याप्त कारण मिलता है ।$p$sim$n$$k$sim$n=13$$k=4$

अंत में, एक दो-नमूना ची-स्क्वेर्ड परीक्षणsim एक अन्य उत्तर में रिपोर्ट किए गए आउटपुट के आउटपुट की तुलना करेगा :

>y <- c(1660,8414,16973,21495,20021,14549,8957,4546,2087,828,313,109)
>chisq.test(cbind(u, y))

data:  cbind(u, y) 
X-squared = 142.2489, df = 11, p-value < 2.2e-16

विशाल ची-स्क्वायड स्टैटिस्टिक एक पी-मूल्य पैदा करता है जो अनिवार्य रूप से शून्य है: एक संदेह के बिना, simअन्य उत्तर से असहमत है। असहमति के दो संभावित संकल्प हैं: इनमें से एक (या दोनों!) उत्तर गलत हैं या वे प्रश्न की विभिन्न व्याख्याओं को लागू करते हैं। उदाहरण के लिए, मैंने अंतिम कार्ड का अवलोकन करने के बाद मतलब निकालने के लिए "डेक खत्म होने के बाद" व्याख्या की है , और यदि स्वीकार्य है, तो प्रक्रिया समाप्त करने से पहले "आप जिस नंबर पर होंगे" को अपडेट करें। संभवत: अंतिम कदम उठाने का मतलब नहीं था। शायद व्याख्या के कुछ ऐसे सूक्ष्म अंतर असहमति की व्याख्या करेंगे, जिस बिंदु पर हम प्रश्न को संशोधित कर सकते हैं ताकि यह स्पष्ट हो सके कि क्या पूछा जा रहा है।

Answer 3

एक सटीक उत्तर है (मैट्रिक्स उत्पाद के रूप में, नीचे बिंदु 4 में प्रस्तुत किया गया है)। इन अवलोकनों से व्युत्पन्न, गणना करने के लिए एक उचित कुशल एल्गोरिथ्म मौजूद है:

1. की एक यादृच्छिक फेरबदल कार्ड बेतरतीब ढंग से फेरबदल से उत्पन्न किया जा सकता कार्ड और फिर बेतरतीब ढंग से interspersing शेष उनके भीतर कार्ड।$N+k$$N$$k$

2. केवल इक्के को हिलाकर, और फिर (पहले अवलोकन को लागू करते हुए) टहनियों को फिर से काटना, फिर थ्रेशर्स, और इसी तरह, इस समस्या को तेरह चरणों की एक श्रृंखला के रूप में देखा जा सकता है।

3. हमें उस कार्ड के मूल्य से अधिक का ट्रैक रखने की आवश्यकता है जो हम मांग रहे हैं। हालांकि, ऐसा करते समय , हमें सभी कार्डों के सापेक्ष चिह्न की स्थिति के लिए खाते की आवश्यकता नहीं है, लेकिन समान या छोटे मूल्य के कार्ड के सापेक्ष केवल इसकी स्थिति।

   पहले इक्का पर एक निशान रखने की कल्पना करें, और उसके बाद पाए गए पहले दो को चिह्नित करें, और इसी तरह। (यदि किसी भी स्तर पर डेक उस कार्ड को प्रदर्शित किए बिना बाहर चला जाता है जिसे हम वर्तमान में मांग रहे हैं, तो हम सभी कार्डों को बिना चिन्हित किए छोड़ देंगे।) प्रत्येक चिह्न के "स्थान" (जब वह मौजूद हो) को समान या निम्न मान के कार्ड की संख्या दें। जब चिह्न बनाया गया था (तब चिह्नित कार्ड सहित)। स्थानों में सभी आवश्यक जानकारी होती है।

4. चिह्न के बाद का स्थान एक यादृच्छिक संख्या है। किसी दिए गए डेक के लिए, इन स्थानों का क्रम एक स्टोकेस्टिक प्रक्रिया बनाता है। यह वास्तव में एक मार्कोव प्रक्रिया है (चर संक्रमण मैट्रिक्स के साथ)। इसलिए सटीक उत्तर की गणना बारह मैट्रिक्स गुणा से की जा सकती है।$i^\text{th}$

इन विचारों का उपयोग करते हुए, यह मशीन सेकंड में (दोहरे सटीक फ्लोटिंग पॉइंट में कंप्यूटिंग) का मान प्राप्त करती है । यह सटीक मान में दिखाया गया है, जो सभी अंकों के लिए सटीक है।$5.8325885529019965$$1/9$

$$\frac{1982600579265894785026945331968939023522542569}{339917784579447928182134345929899510000000000}$$

इस पोस्ट के बाकी विवरण प्रदान करता है, एक कार्यशील कार्यान्वयन (में R) प्रस्तुत करता है , और प्रश्न और समाधान की दक्षता के बारे में कुछ टिप्पणियों के साथ निष्कर्ष निकालता है।

---

एक डेक के यादृच्छिक फेरबदल उत्पन्न करना

यह वास्तव में धारणात्मक स्पष्ट और कोई और अधिक एक "डेक" विचार करने के लिए गणितीय जटिल है (उर्फ मल्टीसेट ) के कार्ड जिनमें से देखते हैं सबसे कम मूल्य वर्ग के, अगली न्यूनतम की, और इतने पर । (जैसा कि सवाल पूछा गया है कि ट्रैक्टर द्वारा निर्धारित डेक ।)$N = k_1+k_2+\cdots+k_m$$k_1$$k_2$$13$$(4,4,\ldots,4)$

कार्ड का एक "यादृच्छिक फेरबदल" एक क्रमचय है जो समान रूप से और यादृच्छिक रूप से से लिया जाता है कार्ड की की जाती है । ये शफ़ल क्योंकि permuting बराबर विन्यास के समूहों में गिर आपस में "इक्के" कुछ भी नहीं बदलता है, permuting आपस में "दुक्की" भी कुछ भी नहीं बदलता है, और इतने पर। इसलिए प्रत्येक समूह के क्रमपरिवर्तन जो कार्ड के सूटों को नजरअंदाज किए जाने पर समान दिखते हैं,क्रमपरिवर्तन। ये समूह, जिनकी संख्या इसलिए बहुराष्ट्रीय गुणांक द्वारा दी गई है$N$$N! = N\times(N-1)\times\cdots\times 2\times 1$$N$$k_1$$k_2$$k_1!\times k_2!\times \cdots \times k_m!$

$$\binom{N}{k_1,k_2,\ldots,k_m} = \frac{N!}{k_1!k_2!\cdots k_m!},$$

डेक के "संयोजन" कहलाते हैं।

संयोजनों की गणना करने का एक और तरीका है। पहले कार्ड केवल संयोजन। वे अपने बीच और उसके आसपास "स्लॉट" हैं जिसमें अगले कार्ड रखे जा सकते हैं। हम इसे एक आरेख के साथ इंगित कर सकते हैं जहां " " कार्डों में से एक को नामित करता है और " " एक स्लॉट को डिजाइन करता है जो और अतिरिक्त कार्ड के बीच पकड़ कर सकता है :$k_1$$k_1!/k_1! = 1$$k_1+1$$k_2$$*$$k_1$$\_$$0$$k_2$

$$\underbrace{\_*\_*\_\cdots\_*\_}_{k_1\text{ stars}}$$

जब अतिरिक्त कार्ड होते हैं, तो सितारों का पैटर्न और नए कार्ड दो में कार्ड को विभाजित करते हैं। इस तरह के सबसे उपसमुच्चय की संख्या ।$k_2$$k_1+k_2$$\binom{k_1+k_2}{k_1,k_2} = \frac{(k_1+k_2)!}{k_1!k_2!}$

इस प्रक्रिया को "threes" के साथ , हम पाते हैं कि पहले कार्डों के बीच उन्हें तरीके । इसलिए इस तरह से पहले कार्ड की व्यवस्था करने के लिए अलग-अलग तरीकों की कुल संख्या बराबर होती है$k_3$$\binom{(k_1+k_2)+k_3}{k_1+k_2,k_3}= \frac{(k_1+k_2+k_3)!}{(k_1+k_2)!k_3!}$$k_1+k_2$$k_1+k_2+k_3$

$$1\times\frac{(k_1+k_2)!}{k_1!k_2!}\times\frac{(k_1+k_2+k_3)!}{(k_1+k_2)!k_3!} = \frac{(k_1+k_2+k_3)!}{k_1!k_2!k_3!}.$$

अंतिम कार्ड्स को समाप्त करने और इन टेलीस्कोपिंग अंशों को गुणा करने के लिए जारी रखने के बाद , हम पाते हैं कि प्राप्त किए गए विभिन्न संयोजनों की संख्या कुल संयोजनों की संख्या के बराबर होती है, जो पहले गिने गए, । इसलिए हमने कोई संयोजन नहीं देखा है। इसका मतलब यह है कि कार्ड को फेरबदल करने की यह अनुक्रमिक प्रक्रिया प्रत्येक संयोजन की संभावनाओं को सही ढंग से पकड़ लेती है, यह मानते हुए कि प्रत्येक चरण में पुराने के बीच नए कार्ड को अलग करने के प्रत्येक संभावित अलग-अलग तरीके से समान रूप से समान संभावना के साथ लिया जाता है।$k_n$$\binom{N}{k_1,k_2,\ldots,k_m}$

स्थान की प्रक्रिया

प्रारंभ में, इक्के हैं और जाहिर है कि बहुत पहले चिह्नित किया गया है। बाद के चरणों में कार्ड, जगह (यदि एक चिह्नित कार्ड मौजूद है) ( माध्यम से से कुछ मूल्य ) के बराबर है , और हम को इंटरसेप्ट करने वाले हैं उनके चारों ओर कार्ड। हम इसे एक आरेख की तरह देख सकते हैं$k_1$ p 1 n k = k $n = k_1 + k_2 + \cdots + k_{j-1}$$p$$1$$n$$k=k_j$

$$\underbrace{\_*\_*\_\cdots\_*\_}_{p-1\text{ stars}}\odot\underbrace{\_*\_\cdots\_*\_}_{n-p\text{ stars}}$$

जहां " " वर्तमान में चिह्नित प्रतीक को नामित करता है। स्थान इस मूल्य पर सशर्त , हम इस संभावना को खोजना चाहते हैं कि अगली जगह बराबर होगी ( माध्यम से से कुछ मूल्य , खेल के नियमों के अनुसार, अगली जगह बाद आनी चाहिए , जहाँ _ )। यदि हम यह पता लगा सकते हैं कि नए कार्ड को खाली करने के लिए कितने तरीके हैं , ताकि अगली जगह बराबर हो जाए , तो हम इन कार्डों को के तरीकों की कुल संख्या से विभाजित कर सकते हैं ( बराबर , जैसा कि हमने देखा है) प्राप्त करने के लिए$\odot$$p$$q$$1$$n+k$$p$$q\ge p+1$$k$$q$$\binom{n+k}{k}$संक्रमण संभावना है कि जगह से । (जगह के लिए पूरी तरह से गायब होने के लिए एक संक्रमण संभावना भी होगी जब कोई भी नया कार्ड चिह्नित कार्ड का पालन नहीं करता है, लेकिन इसे स्पष्ट रूप से गणना करने की कोई आवश्यकता नहीं है।)$p$$q$

आइए इस स्थिति को दर्शाने के लिए आरेख को अपडेट करें:

$$\underbrace{\_*\_*\_\cdots\_*\_}_{p-1\text{ stars}}\odot\underbrace{**\cdots*}_{s\text{ stars}}\ \vert\ \underbrace{\_*\_\cdots\_*\_}_{n-p-s\text{ stars}}$$

वर्टिकल बार " " दिखाता है कि चिह्नित कार्ड के बाद पहला नया कार्ड कहां होता है: इसलिए कोई नया कार्ड इसलिए और बीच प्रकट नहीं हो सकता (और इसलिए उस अंतराल में कोई स्लॉट नहीं दिखाया गया है)। हम नहीं जानते कि इस अंतराल में कितने तारे हैं, इसलिए मैंने अभी इसे कहा है (जो कि शून्य हो सकता है) अज्ञात गायब हो जाएगा जब हम इसके और बीच संबंध खोज लेंगे ।$\vert$$\odot$$\vert$$s$$s$$q$

मान लीजिए, फिर, हम बिखेरना सितारों के आसपास नए कार्ड से पहले और then-- की है कि स्वतंत्र रूप से --we शेष बिखेरना के बाद सितारों के आसपास नए कार्ड । वहां$j$$\odot$$k-j-1$$\vert$

$$\tau_{n,k}(s,p) = \binom{(p-1)+j}{j}\binom{(n-p-s) + (k-j)-1}{k-j-1}$$

इसे करने के तरीके। सूचना है, हालांकि - इस विश्लेषण के trickiest हिस्सा है - कि के स्थान पर के बराबर होती है क्योंकि$\vert$$p+s+j+1$

• कर रहे हैं पर या निशान से पहले "पुराने" कार्ड।$p$
• हैं चिह्न के बाद लेकिन इससे पहले वर्ष कार्ड ।$s$$\vert$
• हैं निशान से पहले नए कार्ड।$j$
• एक नया कार्ड है जिसका प्रतिनिधित्व स्वयं करता है।$\vert$

इस प्रकार, हमें स्थान से स्थान के संक्रमण के बारे में जानकारी देता है । हम के सभी संभव मूल्यों के लिए ध्यान से इस जानकारी को ट्रैक करती है , और योग इन सभी (संबंध तोड़ना) संभावनाओं में, हम जगह की सशर्त संभावना प्राप्त जगह निम्नलिखित ,p q = p + s + j + 1 s q $\tau_{n,k}(s,p)$$p$$q=p+s+j+1$$s$$q$$p$

$${\Pr}_{n,k}(q|p) = \left(\sum_j \binom{p-1+j}{j}\binom{n+k-q}{k-j-1}\right) / \binom{n+k}{k}$$

जहाँ योग से शुरू होता है और पर समाप्त होता है । (इस राशि की चर लंबाई का पता चलता है। विशेष मामलों को छोड़कर और फ़ंक्शन के रूप में इसके लिए एक बंद सूत्र होने की संभावना नहीं है ।)$j=\max(0, q-(n+1))$$j=\min(k-1, q-(p+1)$$n, k, q,$$p$

एल्गोरिथ्म

प्रारंभ में संभावना कि स्थान होगा और संभाव्यता यह में कोई अन्य संभावित मूल्य । यह एक वेक्टर द्वारा दर्शाया जा सकता है ।$1$$1$$0$$2, 3, \ldots, k_1$$p_1 = (1, 0, \ldots, 0)$

अगले कार्डों को बाद , वेक्टर को संक्रमण मैट्रिक्स से गुणा करके (बाईं ओर) में अपडेट किया है। । यह तब तक दोहराया जाता है जब तक सभी कार्ड नहीं डाल दिए जाते। प्रत्येक चरण में, प्रायिकता वेक्टर में प्रविष्टियों का योग मौका है कि कुछ कार्ड को चिह्नित किया गया है। जो भी मूल्य बराबर करने के लिए रहता है इसलिए यह मौका है कि कोई भी कार्ड चरण के बाद चिह्नित न हो$k_2$$p_1$$p_2$$(\Pr_{k_1,k_2}(q|p), 1\le p\le k_1, 1\le q\le k_2)$$k_1+k_2+\cdots+k_m$$j$$p_j$$1$$j$। इन मूल्यों में क्रमिक अंतर इसलिए हमें संभावना देते हैं कि हम टाइप का एक कार्ड नहीं खोज सकते हैं : यह उस कार्ड के मूल्य की संभावना वितरण है जिसे हम खेल के अंत में डेक से बाहर निकलने के लिए देख रहे थे। ।$j$

---

कार्यान्वयन

निम्न Rकोड एल्गोरिथ्म को लागू करता है। यह पूर्ववर्ती चर्चा को समानता देता है। सबसे पहले, संक्रमण संभावनाओं की गणना t.matrix( द्वारा विभाजन के साथ सामान्यीकरण के बिना , कोड का परीक्षण करते समय गणनाओं को ट्रैक करना आसान बनाता है):$\binom{n+k}{k}$

t.matrix <- function(q, p, n, k) {
  j <- max(0, q-(n+1)):min(k-1, q-(p+1))
  return (sum(choose(p-1+j,j) * choose(n+k-q, k-1-j))
}

इसका उपयोग कोtransition अपडेट करने के लिए किया जाता है । यह संक्रमण मैट्रिक्स की गणना करता है और गुणन करता है। यदि प्रारंभिक खाली वेक्टर है तो यह प्रारंभिक वेक्टर की गणना करने का भी ध्यान रखता है :$p_{j-1}$$p_j$$p_1$p

#
# `p` is the place distribution: p[i] is the chance the place is `i`.
#
transition <- function(p, k) {
  n <- length(p)
  if (n==0) {
    q <- c(1, rep(0, k-1))
  } else {
    #
    # Construct the transition matrix.
    #
    t.mat <- matrix(0, nrow=n, ncol=(n+k))
    #dimnames(t.mat) <- list(p=1:n, q=1:(n+k))
    for (i in 1:n) {
      t.mat[i, ] <- c(rep(0, i), sapply((i+1):(n+k), 
                                        function(q) t.matrix(q, i, n, k)))
    }
    #
    # Normalize and apply the transition matrix.
    #
    q <- as.vector(p %*% t.mat / choose(n+k, k))
  }
  names(q) <- 1:(n+k)
  return (q)
}

अब हम आसानी से किसी भी डेक के लिए प्रत्येक चरण में गैर-मार्क संभावनाओं की गणना कर सकते हैं:

#
# `k` is an array giving the numbers of each card in order;
# e.g., k = rep(4, 13) for a standard deck.
#
# NB: the *complements* of the p-vectors are output.
#
game <- function(k) {
  p <- numeric(0)
  q <- sapply(k, function(i) 1 - sum(p <<- transition(p, i)))
  names(q) <- names(k)
  return (q)
}

यहाँ वे मानक डेक के लिए हैं:

k <- rep(4, 13)
names(k) <- c("A", 2:9, "T", "J", "Q", "K")
(g <- game(k))

आउटपुट है

         A          2          3          4          5          6          7          8          9          T          J          Q          K 
0.00000000 0.01428571 0.09232323 0.25595013 0.46786622 0.66819134 0.81821790 0.91160622 0.96146102 0.98479430 0.99452614 0.99818922 0.99944610

नियमों के अनुसार, यदि एक राजा को चिह्नित किया गया था, तो हम किसी भी आगे के कार्ड की तलाश नहीं करेंगे: इसका मतलब है कि का मूल्य बढ़ाना होगा । ऐसा करने पर, अंतर "उस संख्या का वितरण करते हैं जो आप तब करेंगे जब डेक खत्म हो जाएगा":$0.9994461$$1$

> g[13] <- 1; diff(g)
          2           3           4           5           6           7           8           9           T           J           Q           K 
0.014285714 0.078037518 0.163626897 0.211916093 0.200325120 0.150026562 0.093388313 0.049854807 0.023333275 0.009731843 0.003663077 0.001810781

(मोंटे-कार्लो अनुकरण का वर्णन करने वाले एक अलग उत्तर में रिपोर्ट में इस आउटपुट की तुलना करें: वे यादृच्छिक भिन्नता की अपेक्षित मात्रा तक समान दिखाई देते हैं।)

अपेक्षित मूल्य तत्काल है:

> sum(diff(g) * 2:13)
[1] 5.832589

सभी ने बताया, इसके लिए केवल एक दर्जन लाइनें या निष्पादन योग्य कोड की आवश्यकता थी। मैंने इसे छोटे मूल्यों ( ) के लिए हाथ की गणना के खिलाफ जाँच की है । इस प्रकार, यदि कोड और समस्या के पूर्ववर्ती विश्लेषण के बीच कोई विसंगति स्पष्ट हो जाती है, तो कोड पर भरोसा करें (क्योंकि विश्लेषण में टाइपोग्राफिकल त्रुटियां हो सकती हैं)।$k$$3$

---

टिप्पणियों

अन्य दृश्यों के लिए संबंध

जब प्रत्येक कार्ड में से एक होता है, तो वितरण पूरे संख्याओं के पारस्परिक का एक क्रम होता है:

> 1/diff(game(rep(1,10)))
[1]      2      3      8     30    144    840   5760  45360 403200

जगह पर मूल्य है(जगह पर शुरू )। यह पूर्णांक अनुक्रमों के ऑनलाइन विश्वकोश में A001048 अनुक्रम है। तदनुसार, हम निरंतर ("अनुकूल" डेक) के साथ डेक के लिए एक बंद सूत्र के लिए उम्मीद कर सकते हैं जो इस अनुक्रम को सामान्य करेगा, जिसमें स्वयं कुछ गहरा अर्थ है। (उदाहरण के लिए, यह क्रमपरिवर्तन समूहों में सबसे बड़े संयुग्मन वर्गों के आकार को गिनता है और ट्रिनोमियल गुणांक से संबंधित भी है ।) (दुर्भाग्य से, लिए सामान्यीकरण में पारस्परिकता आमतौर पर पूर्णांक नहीं हैं।)$i$$i! + (i-1)!$$i=1$$k_i$$k\gt 1$

एक स्टोकेस्टिक प्रक्रिया के रूप में खेल

हमारे विश्लेषण से यह स्पष्ट होता है कि वैक्टरों के प्रारंभिक गुणांक , , स्थिर हैं। उदाहरण के लिए, आइए इसके आउटपुट को ट्रैक करें क्योंकि यह कार्ड के प्रत्येक समूह को संसाधित करता है:$i$$p_j$$j\ge i$game

> sapply(1:13, function(i) game(rep(4,i)))

[[1]]
[1] 0

[[2]]
[1] 0.00000000 0.01428571

[[3]]
[1] 0.00000000 0.01428571 0.09232323

[[4]]
[1] 0.00000000 0.01428571 0.09232323 0.25595013

...

[[13]]
 [1] 0.00000000 0.01428571 0.09232323 0.25595013 0.46786622 0.66819134 0.81821790 0.91160622 0.96146102 0.98479430 0.99452614 0.99818922 0.99944610

उदाहरण के लिए, अंतिम वेक्टर का दूसरा मान (52 कार्ड के पूर्ण डेक के साथ परिणामों का वर्णन) दूसरे समूह के संसाधित होने के बाद पहले से ही दिखाई दिया (और बराबर है । इस प्रकार, यदि आप केवल कार्ड के मूल्य के बारे में जानकारी चाहते हैं , तो आपको केवल कार्ड के डेक के लिए गणना ।$1/\binom{8}{4}=1/70$$j^\text{th}$$k_1+k_2+\cdots+k_j$

क्योंकि मूल्य का एक कार्ड अंकन नहीं की संभावना जल्दी से के करीब हो रही है के रूप में बढ़ जाती है, के बाद चार सूट में कार्ड के प्रकार हम लगभग उम्मीद के लिए एक सीमित मूल्य पर पहुँच गए हैं। दरअसल, सीमित मान लगभग ( कार्ड के एक डेक के लिए गणना की जाती है , जिस बिंदु पर डबल सटीक गोलाई त्रुटि किसी भी आगे जाने से रोकती है)।$j$$1$$j$$13$$5.833355$$4 \times 32$

समय

-vector पर लागू किए गए एल्गोरिदम को देखते हुए, हम देखते हैं कि इसकी समयावधि समानुपाती होनी चाहिए और - एक कच्चे ऊपरी बाउंड का उपयोग करना - आनुपातिक से कोई भी बदतर नहीं। । के लिए और माध्यम से तक सभी गणनाओं का समय निर्धारित करके , और केवल अपेक्षाकृत लंबे समय ( सेकंड या उससे अधिक) लेने वाले लोगों का विश्लेषण करके , मैं अनुमान लगाता हूं कि गणना समय लगभग , इस ऊपरी-सीमा मूल्यांकन का समर्थन करता है।( k , k , … , k ) k 2 m 3 k = १ 10 n = १० ३० १ / २ O ( k २ n २.९ ​​३$m$$(k,k, \ldots, k)$$k^2$$m^3$$k=1$$7$$n=10$$30$$1/2$$O(k^2 n^{2.9})$

इन एसिम्पटोटिक्स का एक उपयोग बड़ी समस्याओं के लिए गणना समय को प्रोजेक्ट करना है। उदाहरण के लिए, यह देखते हुए कि केस में लगभग सेकंड लगते हैं , हम अनुमान लगाएंगे कि (बहुत ही दिलचस्प) केस लगभग सेकंड। (यह वास्तव में सेकंड लेता है ।)$k=4, n=30$कश्मीर = 1 , n = 100 1.31 ( 1 / 4 ) 2 ( 100 / 30 ) 2.9 ≈ 2.7 $1.31$$k=1, n=100$$1.31(1/4)^2(100/30)^{2.9}\approx 2.7$$2.87$

Answer 4

पर्ल में एक साधारण मोंटे कार्लो को हैक किया और लगभग पाया ।$5.8329$

#!/usr/bin/perl

use strict;

my @deck = (1..13) x 4;

my $N = 100000; # Monte Carlo iterations.

my $mean = 0;

for (my $i = 1; $i <= $N; $i++) {
    my @d = @deck;
    fisher_yates_shuffle(\@d);
    my $last = 0;
        foreach my $c (@d) {
        if ($c == $last + 1) { $last = $c }
    }
    $mean += ($last + 1) / $N;
}

print $mean, "\n";

sub fisher_yates_shuffle {
    my $array = shift;
        my $i = @$array;
        while (--$i) {
        my $j = int rand($i + 1);
        @$array[$i, $j] = @$array[$j, $i];
    }
}

Comments

इस और सभी पिछले उत्तरों के बीच की तीव्र विसंगति को देखते हुए , दो सिमुलेशन और एक सैद्धांतिक (सटीक) सहित, मुझे संदेह है कि आप प्रश्न को एक अलग तरीके से व्याख्या कर रहे हैं। आपकी ओर से किसी भी स्पष्टीकरण के अभाव में, हमें इसे गलत होने के रूप में लेना होगा। (मुझे लगता है कि आप कम से कम एक गिनती की जा सकती है, ऐसी स्थिति में अपने 4.8 की तुलना में किया जाना चाहिए ५.८३,२५८ करने के लिए ...; लेकिन फिर भी, अपने दो परिशुद्धता के महत्वपूर्ण अंक इस समस्या में कोई अतिरिक्त जानकारी प्रदान करते हैं।)

— whuber

हां! एक-एक गलती हुई।

— ज़ेन