मान लीजिए कि सभी पक्षों के पास समान संभावनाएं हैं। आइए सामान्यीकरण और जरूरत है जब तक पक्ष रोल की अपेक्षित संख्या को खोजने के 1 प्रकट हुई है n 1 बार, पक्ष 2 प्रकट हुई है n 2 बार, ..., और पक्ष घ प्रकट हुई है n घ बार। क्योंकि पक्षों की पहचान कोई मायने नहीं रखती है (उन सभी के पास समान संभावनाएं हैं), इस उद्देश्य के विवरण को संघनित किया जा सकता है: मान लें कि मुझे 0 पक्ष बिल्कुल दिखाई नहीं देते हैं, मुझे पक्षों में से 1 को दिखाना होगा बस एक बार, ... और मैं एनd=61n12n2dndi0i1inपक्षों को बार प्रदर्शित करना होगा। चलो मैं = ( मैं 0 , मैं 1 , ... , मैं एन ) इस स्थिति और लिखने को नामित ई ( मैं ) रोल की अपेक्षित संख्या के लिए। प्रश्न ई ( 0 , 0 , 0 , 6 ) के लिए पूछता है : i 3 =n=max(n1,n2,…,nd)
i=(i0,i1,…,in)
e(i)
e(0,0,0,6) इंगित करता है कि सभी छह पक्षों को तीन-तीन बार देखा जाना चाहिए।
i3=6
एक आसान पुनरावृत्ति उपलब्ध है। अगले रोल, पक्ष में से एक से मेल खाती है प्रकट होता है पर : यह है कि, या तो हम इसे देखने की जरूरत नहीं है, या हम इसे एक बार देखने के लिए, ..., की जरूरत है या हम यह देखने के लिए की जरूरत n अधिक बार। j हमें इसे देखने के लिए आवश्यक समय की संख्या है।ijnj
जब , हमें इसे देखने की आवश्यकता नहीं थी और कुछ भी नहीं बदलता है। यह संभाव्यता i 0 / d के साथ होता है ।j=0i0/d
जब तो हमें इस तरफ देखने की जरूरत थी। अब एक कम पक्ष है जिसे j बार देखा जाना चाहिए और एक और पक्ष जिसे j - 1 बार देखना होगा । इस प्रकार, मैं j हो जाता है मैं j - 1 और मैं j - 1 हो जाता है मैं j + 1 । घटकों पर यह कार्रवाई करते हैं की मैं नामित किया मैं ⋅ j , ताकिj>0jj−1ijij−1ij−1ij+1ii⋅j
i⋅j=(i0,…,ij−2,ij−1+1,ij−1,ij+1,…,in).
यह संभावना के साथ होता है ।ij/d
हमें केवल इस डाई रोल को गिनना होगा और हमें यह बताने के लिए पुनरावर्तन का उपयोग करना होगा कि कितने और रोल की उम्मीद है। अपेक्षा और कुल संभावना के कानूनों द्वारा,
e(i)=1+i0de(i)+∑j=1nijde(i⋅j)
(आइए समझते हैं कि जब भी , योग में संबंधित शब्द शून्य होता है।)ij=0
अगर , हम किया जाता है और e ( i ) = 0 । अन्यथा हम ई ( i ) के लिए समाधान कर सकते हैं , वांछित पुनरावर्ती सूत्र दे रहे हैंi0=de(i)=0e(i)
e(i)=d+i1e(i⋅1)+⋯+ine(i⋅n)d−i0.(1)
ध्यान दें कि ईवेंट की कुल संख्या हम देखना चाहते है। आपरेशन ⋅ j किसी के लिए एक के बाद कि मात्रा कम कर देता है j > 0 प्रदान की मैं j > 0 है, जो हमेशा मामला है। इसलिए यह पुनरावृत्ति ठीक की गहराई पर समाप्त होती है | मैं | ( 3 के बराबर ( 6 ) =
|i|=0(i0)+1(i1)+⋯+n(in)
⋅jj>0ij>0|i| प्रश्न में)। इसके अलावा (जैसा कि जांचना मुश्किल नहीं है) इस सवाल में प्रत्येक पुनरावृत्ति गहराई पर संभावनाओं की संख्या छोटी है (कभी भी
8 से अधिक नहीं)। नतीजतन, यह एक कुशल विधि है, कम से कम जब संयोजन की संभावनाएं बहुत अधिक नहीं होती हैं और हम मध्यवर्ती परिणामों को याद करते हैं (ताकि
ई काकोई मूल्यएक से अधिक बार गणना न हो)।
3(6)=188e
मैं गणना करता हूं कि
e(0,0,0,6)=228687860450888369984000000000≈32.677.
यह मुझे बहुत छोटा लग रहा था, इसलिए मैंने एक सिमुलेशन (उपयोग करके R) चलाया । पासा के तीन मिलियन से अधिक रोल के बाद, इस खेल को 100,000 से अधिक बार पूरा करने के लिए खेला गया था, जिसकी औसत लंबाई । उस अनुमान की मानक त्रुटि 0.027 है : इस औसत और सैद्धांतिक मूल्य के बीच का अंतर महत्वहीन है, सैद्धांतिक मूल्य की सटीकता की पुष्टि करता है।32.6690.027
लंबाई का वितरण ब्याज का हो सकता है। (जाहिर है कि यह से शुरू होना चाहिए , सभी छह पक्षों को प्रत्येक तीन बार इकट्ठा करने के लिए आवश्यक रोल की न्यूनतम संख्या।)18
# Specify the problem
d <- 6 # Number of faces
k <- 3 # Number of times to see each
N <- 3.26772e6 # Number of rolls
# Simulate many rolls
set.seed(17)
x <- sample(1:d, N, replace=TRUE)
# Use these rolls to play the game repeatedly.
totals <- sapply(1:d, function(i) cumsum(x==i))
n <- 0
base <- rep(0, d)
i.last <- 0
n.list <- list()
for (i in 1:N) {
if (min(totals[i, ] - base) >= k) {
base <- totals[i, ]
n <- n+1
n.list[[n]] <- i - i.last
i.last <- i
}
}
# Summarize the results
sim <- unlist(n.list)
mean(sim)
sd(sim) / sqrt(length(sim))
length(sim)
hist(sim, main="Simulation results", xlab="Number of rolls", freq=FALSE, breaks=0:max(sim))
कार्यान्वयन
यद्यपि की पुनरावर्ती गणना सरल है, यह कुछ कंप्यूटिंग वातावरणों में कुछ चुनौतियां प्रस्तुत करता है। इनमें से प्रमुख ई ( i ) के मानों को संगृहीत कर रहे हैं। यह आवश्यक है, अन्यथा प्रत्येक मूल्य (अतिरेक) की गणना बहुत बड़ी संख्या में होगी। हालाँकि, संभावित रूप से मेरे द्वारा अनुक्रमित सरणी के लिए स्टोरेज की आवश्यकता बहुत अधिक हो सकती है। आदर्श रूप में, मैं के केवल मूल्यों को गणना के दौरान वास्तव में सामना करना पड़ता है जिन्हें संग्रहीत किया जाना चाहिए। यह एक प्रकार के साहचर्य सरणी के लिए कहता है ।ee(i)ii
RiEi⋅j%.%
e
x <- (d + sum(sapply(1:n, function(i) j[i+1]*e.(j %.% i))))/(d - j[1])
(1)1R10
0.01e(c(0,0,0,6))
32.6771634160506
संचित फ़्लोटिंग पॉइंट राउंडऑफ़ त्रुटि ने पिछले दो अंकों को नष्ट कर दिया है (जो इसके 68बजाय होना चाहिए 06)।
e <- function(i) {
#
# Create a data structure to "memoize" the values.
#
`[[<-.AA` <- function(x, i, value) {
class(x) <- NULL
x[[paste(i, collapse=",")]] <- value
class(x) <- "AA"
x
}
`[[.AA` <- function(x, i) {
class(x) <- NULL
x[[paste(i, collapse=",")]]
}
E <- list()
class(E) <- "AA"
#
# Define the "." operation.
#
`%.%` <- function(i, j) {
i[j+1] <- i[j+1]-1
i[j] <- i[j] + 1
return(i)
}
#
# Define a recursive version of this function.
#
e. <- function(j) {
#
# Detect initial conditions and return initial values.
#
if (min(j) < 0 || sum(j[-1])==0) return(0)
#
# Look up the value (if it has already been computed).
#
x <- E[[j]]
if (!is.null(x)) return(x)
#
# Compute the value (for the first and only time).
#
d <- sum(j)
n <- length(j) - 1
x <- (d + sum(sapply(1:n, function(i) j[i+1]*e.(j %.% i))))/(d - j[1])
#
# Store the value for later re-use.
#
E[[j]] <<- x
return(x)
}
#
# Do the calculation.
#
e.(i)
}
e(c(0,0,0,6))
अंत में, यहां मूल गणितज्ञ कार्यान्वयन है जो सटीक उत्तर का उत्पादन करता है। संस्मरण को मुहावरेदार अभिव्यक्ति के माध्यम से पूरा किया जाता है e[i_] := e[i] = ..., लगभग सभी पूर्वाग्रहों को समाप्त करता है R। आंतरिक रूप से, हालांकि, दो कार्यक्रम समान तरीके से एक ही काम कर रहे हैं।
shift[j_, x_List] /; Length[x] >= j >= 2 := Module[{i = x},
i[[j - 1]] = i[[j - 1]] + 1;
i[[j]] = i[[j]] - 1;
i];
e[i_] := e[i] = With[{i0 = First@i, d = Plus @@ i},
(d + Sum[If[i[[k]] > 0, i[[k]] e[shift[k, i]], 0], {k, 2, Length[i]}])/(d - i0)];
e[{x_, y__}] /; Plus[y] == 0 := e[{x, y}] = 0
e[{0, 0, 0, 6}]
228687860450888369984000000000
