As, 2, 3 vb. Elde edene kadar kart çekildikten sonra beklenen sayı I

Aşağıdakileri çözerken sorun yaşıyorum.

Bir as alana kadar, kartları standart bir 52 kartlık desteden yedek olmadan alırsınız. 2 elde edene kadar kalandan çekiyorsunuz. 3 ile devam ediyorsunuz.

İzin vermek doğaldı

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

Yani sorun temel olarak güverte bittiğinde üzerinde olma olasılığını bulmak demektir $k$, yani:

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

bunu görebiliyorum

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

ama daha fazla alamadım ...

@ gung'un fikrini takiben, beklenen değerin 5.84 olacağına inanıyorum? ve yorumları yorumlamamdan, "A" nın neredeyse imkansız bir değer olduğunu varsayıyorum (destedeki son dört kartın hepsi as olmadığı sürece). İşte 100.000 iterasyon monte carlo simülasyonunun sonuçları

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 

ve onunla oynamak istemeniz durumunda R kodu.

# 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 )

Bir simülasyon için hem hızlı hem de doğru olmak çok önemlidir . Her iki hedef de programlama ortamının temel yeteneklerini hedefleyen kod yazmanın yanı sıra mümkün olduğunca kısa ve basit kod yazmayı önerir, çünkü basitlik netlik kazandırır ve netlik doğruluğu artırır. İşte her ikisinde de elde etme girişimim 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
}

Bunu tekrarlanabilir bir şekilde uygulamak replicate, rastgele sayı tohumunu ayarladıktan sonra işlevde olduğu gibi yapılabilir

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

Bu yavaş, ancak oldukça uzun (ve dolayısıyla kesin) simülasyonları beklemeden tekrar tekrar yürütecek kadar hızlı. Sonucu sergilememizin birkaç yolu vardır. Ortalamasıyla başlayalım:

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

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

İkincisi standart hatadır: simüle edilen ortalamanın gerçek değerin iki veya üç SE'si içinde olmasını bekliyoruz. Bu gerçek beklentiyi ve arasında bir yere$5.817$$5.853$ .

Ayrıca frekanslarda (ve bir tablo haline görmek isteyebilirsiniz onların standart hataları). Aşağıdaki kod, tabloyu biraz güzelleştirir:

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)

İşte çıktı:

                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

---

Simülasyonun bile doğru olduğunu nasıl bilebiliriz? Bunun bir yolu, daha küçük sorunlar için kapsamlı bir şekilde test etmektir. Bu nedenle, bu kod, problemin küçük bir genellemesine saldırmak için yazılmıştır, ayrı kart ve takım ile değiştirilmiştir . Bununla birlikte, test için kodu bir güverte önceden belirlenmiş bir sırada besleyebilmek önemlidir. Aynı algoritmaya biraz farklı bir arayüz yazalım:$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)
}

(Her yerde drawyerine kullanmak mümkündür sim, ancak başında yapılan ekstra çalışma drawonu iki kat daha yavaş yapar sim.)

Bunu, belirli bir destenin her farklı karıştırmasına uygulayarak kullanabiliriz . Buradaki amaç sadece birkaç kerelik testler olduğundan, bu karıştırmaları oluşturmadaki verimlilik önemsizdir. İşte hızlı bir kaba kuvvet yolu:

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,]

Şimdi dsıraları tüm karışıklıkları içeren bir veri çerçevesi. drawHer satıra uygulayın ve sonuçları sayın:

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

Anlık olarak resmi bir testte kullanacağımız çıktı

   2    3    4 
 420  784 1316 

( değerini anlamak kolaydır, bu arada: ancak tüm ikişer tüm aslardan önce gelirse kart üzerinde çalışmaya devam edeceğiz . Bunun gerçekleşme şansı (iki takımla) . ayrı karıştırmadan bu özelliğe sahiptir.)2 1 / ( 2 + $420$$2$25202520/6=$1/\binom{2+2}{2} = 1/6$$2520$$2520/6 = 420$

Çıktıyı ki-kare testi ile test edebiliriz. Bu amaçla , takımda bu farklı kart örneğine kez uygulanır :sim $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

Çünkü kadar yüksek ki, ne arasında anlamlı bir fark bulmak diyor ve değerler ayrıntılı numaralandırma tarafından hesaplanan. Diğer bazı (küçük) değerleri için bu egzersizi tekrarlamak ve bize güven için yeterli bir sebep veren karşılaştırılabilir sonuçlar üretir uygulandığında ve .$p$sim$n$$k$sim$n=13$$k=4$

Son olarak, iki örneklem ki-kare testi çıktısını karşılaştırır simçıktı başka bir yanıt rapor için:

>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

Muazzam ki-kare istatistiği, esasen sıfır olan bir p değeri üretir: şüphesiz simdiğer cevaba katılmaz. Anlaşmazlığın iki olası çözümü vardır: bu cevaplardan biri (veya her ikisi!) Yanlıştır veya sorunun farklı yorumlarını uygularlar. Örneğin, "deste bittikten sonra" ve son kartı gözlemledikten sonra ve izin veriliyorsa, prosedürü sonlandırmadan önce "üzerinde olacağınız numarayı" güncelleyerek yorumladım . Muhtemelen son adımın atılması gerekmiyordu. Belki de bu tür ince yorum farklılıkları anlaşmazlığı açıklayacaktır, bu noktada soruyu neyin sorulduğunu daha açık hale getirmek için değiştirebiliriz.

Kesin bir cevap var (aşağıdaki 4. maddede sunulan bir matris ürünü şeklinde). Bu gözlemlerden türetilen, hesaplamak için makul derecede etkili bir algoritma vardır:

1. Rastgele bir karışık kartları rastgele karıştırma ile üretilebilir kartlar ve daha sonra rasgele interspersing kalan içlerindeki kartı.$N+k$$N$$k$

2. Sadece asları karıştırarak ve sonra (ilk gözlemi uygulayarak) ikilileri, daha sonra üçleri ve benzerlerini serpiştirerek, bu sorun on üç adımlık bir zincir olarak görülebilir.

3. Aradığımız kartın değerinden daha fazlasını takip etmemiz gerekiyor. Ancak bunu yaparken , işaretin tüm kartlara göre konumunu değil, sadece eşit veya daha küçük değerli kartlara göre konumunu hesaba katmamız gerekmez .

   İlk asın üzerine bir işaret koyduğunuzu ve daha sonra bulunan ilk ikisini işaretlediğinizi düşünün. (Herhangi bir aşamada deste, aradığımız kartı göstermeden biterse, tüm kartları işaretsiz bırakacağız.) Her işaretin "yeri" (varsa) eşit veya daha düşük değerli kartların sayısı olsun işaret yapıldığında (işaretli kartın kendisi dahil) dağıtıldı. Yerler tüm gerekli bilgileri içerir.

4. Sonra yer yapılır işareti rastgele bir sayıdır. Belirli bir güverte için, bu yerlerin sırası stokastik bir süreç oluşturur. Aslında bir Markov sürecidir (değişken geçiş matrisi ile). Bu nedenle, kesin bir cevap on iki matris çarpımından hesaplanabilir.$i^\text{th}$

Bu fikirler kullanılarak, bu makine saniyede (çift kesinlikli kayar nokta ile hesaplama) değeri elde eder . Bu tam değerin gösterilen tüm rakamlar için doğrudur.$5.8325885529019965$$1/9$

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

Bu yazının geri kalanı ayrıntılar sağlar, çalışan bir uygulama sunar (in R) ve sorunun ve çözümün etkinliği hakkında bazı yorumlarla sonuçlanır.

---

Bir güverte rastgele karıştırmalar oluşturma

Aslında kavramsal olarak daha ve en düşük değerde , bir sonraki en düşük olan kartlarının bir "destesini" (aka multiset olarak ) düşünmek artık daha karmaşık değildir . . (Sorulan soru, vektör tarafından belirlenen desteyle ilgilidir .)$N = k_1+k_2+\cdots+k_m$$k_1$$k_2$$13$$(4,4,\ldots,4)$

kartların "rastgele karıştırılması", eşit ve rastgele alınan bir permütasyon kartın permütasyonu . Bu karıştırmalar eşdeğer konfigürasyon gruplarına ayrılır çünkü "as" hiçbir şeyi değiştirmez, "ikişer" aralarına izin vermek de hiçbir şeyi değiştirmez, vb. Bu nedenle, kartların elbiseleri göz ardı edildiğinde özdeş görünen her bir permütasyon grubupermütasyon. Bu nedenle sayıları multinom katsayısı ile verilen bu gruplar$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!},$$

güverte "kombinasyonları" olarak adlandırılır.

Kombinasyonları saymanın başka bir yolu var. İlk kartları yalnızca kombinasyon. Onlar terk sonraki ila çevrelerindeki hangi "yuva" kartları yerleştirilebilir. Bunu, " " kartlarından birini ve " " ile ek kart arasında kullanılabilecek bir yuva belirttiği bir :$k_1$$k_1!/k_1! = 1$$k_1+1$$k_2$$*$$k_1$$\_$$0$$k_2$

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

Ne zaman ek kartlar serpiştirilmiş, yıldızlar ve yeni kart bölümleri deseni iki alt-grup halinde kart. Bu tür alt kümelerin sayısı .$k_2$$k_1+k_2$$\binom{k_1+k_2}{k_1,k_2} = \frac{(k_1+k_2)!}{k_1!k_2!}$

Bu prosedürü "üçerli" ile tekrarlayarak , ilk kartları arasında . Bu nedenle, ilk kartlarını bu şekilde düzenlemenin toplam ayrı yolu sayısı eşittir$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!}.$$

Son kartları bitirdikten ve bu teleskop fraksiyonlarını çoğaltmaya devam ettikten sonra , elde edilen farklı kombinasyon sayısının daha önce sayılan toplam kombinasyon sayısına eşit olduğunu görüyoruz, . Bu yüzden hiçbir kombinasyonu göz ardı ettik. Bu , kartları karıştırmanın bu sıralı işleminin , her aşamada, yeni kartları eski arasında serpiştirmenin her olası farklı yolunun eşit eşit olasılıkla alındığı varsayılarak , her kombinasyonun olasılıklarını yakaladığı anlamına gelir .$k_n$$\binom{N}{k_1,k_2,\ldots,k_m}$

Yer süreci

Başlangıçta, as vardır ve açıkça ilk işaretlenir. Sonraki aşamalarında vardır kartları, yer (belirgin bir kart varsa) eşittir (bazı değer ile ) ve biz serpmek üzere olduğunuz kartları. Bunu aşağıdaki gibi bir diyagramla görselleştirebiliriz$k_1$$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}}$$

burada " " şu anda işaretli sembolü belirtir. Koşullu yer bu değeri , bir sonraki yer eşit olasılığını bulmak istediğiniz (bazı değer ile ; oyunun kurallarına göre, bir sonraki yer sonra gelmelidir , nereden ). Boşluklarda yeni kartları kesişmek için kaç yol olduğunu bulabilirsek , bir sonraki yer eşit olur , bu kartların serpiştirilmesi için toplam yol sayısına bölebiliriz ( , gördüğümüz gibi)$\odot$$p$$q$$1$$n+k$$p$$q\ge p+1$$k$$q$$\binom{n+k}{k}$geçiş olasılığı yer değişir için . (Ayrıca, yeni kartlardan hiçbiri işaretli kartı takip etmediğinde yerin tamamen kaybolması için bir geçiş olasılığı olacaktır, ancak bunu açıkça hesaplamaya gerek yoktur.)$p$$q$

Diyagramı bu durumu yansıtacak şekilde güncelleyelim:

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

"Dikey çubuk ilk yeni kart işaretli kart sonra oluşur gösterir:" yok yeni kart nedenle arasında görünebilir ve (ve bu nedenle herhangi bir yuva bu aralıkta gösterilmiştir). Biz bu yüzden sadece çağrıda, bu aralıkta kaç tane yıldız bilmiyorum bilinmeyen (sıfır olabilir) bunun arasındaki ilişkiyi bulduktan sonra kaybolur .$\vert$$\odot$$\vert$$s$$s$$q$

Varsayalım, o zaman, serpmek yıldızlı etrafında yeni kartlar önce ve sonra-- bağımsız Bunun --we kalan serpmek sonra yıldızların etrafındaki yeni kart . Var$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}$$

bunu yapmanın yolları. Yine de, bu - analizin en zor kısmıdır - yeri eşittir, çünkü$\vert$$p+s+j+1$

• Orada "eski" kartları veya işareti önce.$p$
• Orada işaretinden sonra ama daha önce eski kartlar .$s$$\vert$
• Orada yeni kart işareti önce.$j$
• kendisi tarafından temsil edilen yeni kart var .$\vert$

Böylece, bize yerden geçiş hakkında bilgi verir . Biz olası tüm değerleri için dikkatli bir şekilde, bu bilgileri izlemek zaman ve toplamı , tüm bu (ayrık) olanakları boyunca, yer koşullu olasılığı elde yer aşağıdaki ,$\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}$$

burada toplam, ile başlar ve ile biter . (Bu toplamın değişken uzunluğu, özel durumlar dışında ve bir fonksiyonu olarak kapalı bir formül olması olası değildir .)$j=\max(0, q-(n+1))$$j=\min(k-1, q-(p+1)$$n, k, q,$$p$

Algoritma

Başlangıçta ihtimali vardır yer olacağını ve olasılık o başka muhtemel değere sahip olacaktır . Bu bir vektörü ile temsil edilebilir .$1$$1$$0$$2, 3, \ldots, k_1$$p_1 = (1, 0, \ldots, 0)$

Bir sonraki interspersing sonra kartları, vektör için güncelleştirilir geçiş matris tarafından (solda) çarpılarak . Bu, tüm kartları yerleştirilene kadar tekrarlanır . Her aşamada , olasılık vektörü girişlerin toplamı o şans bazı kart işaretlendi. Değeri eşit yapmak için ne kalırsa, adımından sonra hiçbir kartın işaretlenmemesi ihtimali$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$. Bu değerlerde birbirini takip eden farklılıklar bize işaretlemek için tipi bir kart bulamadığımız olasılığını verir : bu, oyunun sonunda güverte bittiğinde aradığımız kartın değerinin olasılık dağılımıdır .$j$

---

uygulama

Aşağıdaki Rkod algoritmayı uygular. Önceki tartışmaya paraleldir. İlk olarak, geçiş olasılıklarının hesaplanması şu şekilde gerçekleştirilir t.matrix( ile bölünme normalleştirilmeden , kodu test ederken hesaplamaları izlemeyi kolaylaştırır):$\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))
}

Bu, yitransition olarak güncellemek için kullanılır . Geçiş matrisini hesaplar ve çarpma işlemini gerçekleştirir. Argüman boş bir vektörse, başlangıç ​​vektörünün hesaplanmasıyla da ilgilenir :$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)
}

Artık herhangi bir güverte için her aşamada işaretsiz olasılıkları kolayca hesaplayabiliriz:

#
# `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)
}

İşte standart güverte için:

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

Çıktı

         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

Bir kral o zaman başka kartlar için bakmak olmaz kutlandı eğer kurallara göre, Bu değeri ifade eder yükselmiştir zorundadır . Bunu yaptıktan sonra, farklar "güverte bittiğinde olacağınız sayının" dağılımını verir:$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

(Bunu, Monte-Carlo simülasyonunu açıklayan ayrı bir cevapta raporladığım çıktı ile karşılaştırın: beklenen miktarlarda rastgele varyasyona kadar aynı görünüyorlar.)

Beklenen değer hemen:

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

Tüm bunlar, bunun sadece bir düzine satır çalıştırılabilir kod gerektirdiğini söyledi. Küçük değerleri ( kadar ) için el hesaplamalarına karşı kontrol ettim . Bu nedenle, kod ile sorunun önceki analizi arasında herhangi bir tutarsızlık ortaya çıkarsa, koda güvenin (analizin tipografik hataları olabileceğinden).$k$$3$

---

Uyarılar

Diğer dizilerle ilişkiler

Her bir karttan biri olduğunda, dağıtım tam sayıların karşılıklı dizisidir:

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

Yerde değer olan( numaralı yerden başlayarak ). Bu, Tamsayı Dizilerinin Çevrimiçi Ansiklopedisinde A001048 dizisidir . Buna göre, sabit bir ("uygun" desteler) olan güvertelerin kendisi için bazı derin anlamları olan bu diziyi genelleştirecek kapalı bir formül . (Örneğin, permütasyon gruplarındaki en büyük eşleniklik sınıflarının boyutlarını sayar ve aynı zamanda trinomiyal katsayılarla da ilişkilidir .) (Ne yazık ki, için genellemedeki karşılıklılıklar genellikle tamsayı değildir.)$i$$i! + (i-1)!$$i=1$$k_i$$k\gt 1$

Stokastik bir süreç olarak oyun

, vektörlerinin başlangıç katsayılarının sabit olduğunu açıkça ortaya koymaktadır . Örneğin, her bir kart grubunu işlerken çıktısını takip edelim :$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

Örneğin, son vektörün ikinci değeri ( 52 kartlık tam desteyle sonuçları açıklayan), ikinci grup işlendikten sonra ortaya çıkmıştır (ve eşittir ). Bu nedenle, yalnızca kart değeri üzerinden işaretler hakkında bilgi istiyorsanız , yalnızca kart destesi için hesaplama yapmanız gerekir .$1/\binom{8}{4}=1/70$$j^\text{th}$$k_1+k_2+\cdots+k_j$

Değer bir kart işaretleme değil şansı Çünkü hızla yakın olmaktadır olarak arttıkça, sonra dört takımdaki kağıt türleri neredeyse beklenti için belli bir sınır değeri ulaştı. Gerçekten de, sınırlayıcı değer yaklaşık ( kartlık bir destede hesaplanır , bu noktada çift hassas yuvarlama hatası daha ileri gitmeyi önler).$j$$1$$j$$13$$5.833355$$4 \times 32$

Zamanlama

-vector için uygulanan algoritmaya bakıldığında, zamanlamasının ile orantılı olması gerektiğini ve - ham bir üst sınır kullanarak - orantılı olarak daha kötü olmadığını görüyoruz. . Tüm hesaplamaları ila ve ila için zamanlayarak ve yalnızca nispeten uzun süreleri ( saniye veya daha uzun) alan zamanları analiz ederek , hesaplama süresinin yaklaşık ) olduğunu tahmin ediyorum. , bu üst sınır değerlendirmesini desteklemektedir.( k , k , ... , k ) k 2 m 3 k = 1 7 , n = 10 , 30 1 / 2 , O ( k 2 , n 2.9$m$$(k,k, \ldots, k)$$k^2$$m^3$$k=1$$7$$n=10$$30$$1/2$$O(k^2 n^{2.9})$

Bu asimptotiklerin bir kullanımı daha büyük problemler için hesaplama sürelerini yansıtmaktır. Örneğin, vakasının yaklaşık saniye sürdüğünü görmek, (çok ilginç) vakasının yaklaşık saniye. (Aslında saniye sürer .)1.31 k = 1 , n = 100 1.31 ( 1 / 4 ) 2 ( 100 / 30 ) 2.9 ≈ 2,7 $k=4, n=30$$1.31$$k=1, n=100$$1.31(1/4)^2(100/30)^{2.9}\approx 2.7$$2.87$

Perl'de basit bir Monte ve yaklaşık buldu .$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];
    }
}