จำนวนที่คาดว่าฉันจะอยู่หลังจากวาดการ์ดจนกว่าฉันจะได้รับเอซ 2, 3 และอื่น ๆ

ฉันมีปัญหาในการแก้ปัญหาต่อไปนี้

คุณจั่วไพ่จากสำรับมาตรฐาน 52 ใบโดยไม่ต้องเปลี่ยนจนกว่าคุณจะได้เอซ คุณดึงออกจากสิ่งที่เหลืออยู่จนกว่าคุณจะได้รับ 2. คุณดำเนินการต่อด้วย 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$$

แต่ไม่สามารถรับได้อีกต่อไป ...

ตามความคิดของ @ gung ฉันเชื่อว่าค่าที่คาดหวังจะเป็น 5.84 และจากการตีความความคิดเห็นของฉันฉันถือว่า "A" เป็นค่าที่เกือบเป็นไปไม่ได้ (ยกเว้นว่าไพ่สี่ใบสุดท้ายในสำรับเป็นเอซทั้งหมด) นี่คือผลลัพธ์ของการจำลองมอนเตคาร์โล 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 

และนี่คือรหัส R ในกรณีที่คุณต้องการเล่นกับมัน ..

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

สำหรับการจำลองสิ่งสำคัญคือการแก้ไขให้ถูกต้องและรวดเร็ว วัตถุประสงค์ทั้งสองนี้แนะนำให้เขียนโค้ดที่มีความสามารถหลักของสภาพแวดล้อมการเขียนโปรแกรมรวมถึงโค้ดที่สั้นและง่ายที่สุดเนื่องจากความเรียบง่ายให้ความชัดเจนและความชัดเจนส่งเสริมความถูกต้อง นี่คือความพยายามของฉันเพื่อให้บรรลุทั้งใน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

ข้อผิดพลาดหลังคือข้อผิดพลาดมาตรฐาน: เราคาดว่าค่าเฉลี่ยที่จำลองไว้จะอยู่ภายในสองหรือสาม SEs ของค่าจริง ว่าสถานที่บางแห่งความคาดหวังที่แท้จริงระหว่างและ$5.817$$5.853$ 5.853

นอกจากนี้เรายังอาจต้องการที่จะเห็นการจัดระเบียบของความถี่ (และพวกเขามีข้อผิดพลาดมาตรฐาน) รหัสต่อไปนี้ prettifies การจัดระเบียบเล็กน้อย:

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)

เราสามารถใช้นี้โดยนำไปใช้กับทุกสับเปลี่ยนที่แตกต่างกันของดาดฟ้าที่กำหนด เนื่องจากจุดประสงค์ที่นี่เป็นเพียงการทดสอบแบบครั้งเดียวไม่กี่ครั้งประสิทธิภาพในการสร้าง shuffles เหล่านี้จึงไม่สำคัญ นี่คือวิธีที่ดุร้ายกำลังอย่างรวดเร็ว:

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เป็นกรอบข้อมูลที่มีแถวมี shuffles ทั้งหมด ใช้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 $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

เนื่องจากมีค่าสูงมากเราจึงไม่พบความแตกต่างอย่างมีนัยสำคัญระหว่างสิ่งที่พูดกับค่าที่คำนวณโดยการแจงนับอย่างละเอียด การทำซ้ำการออกกำลังกายนี้สำหรับบางคนอื่น ๆ (เล็ก) ค่าของและก่อให้เกิดผลลัพธ์เทียบเคียงให้เรามีเหตุผลเพียงพอที่จะไว้วางใจเมื่อนำไปใช้และ 4$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

สถิติแบบไคสแควร์ขนาดมหึมาก่อให้เกิดค่า p ซึ่งเป็นศูนย์: โดยไม่ต้องสงสัยเลยsimไม่เห็นด้วยกับคำตอบอื่น มีวิธีแก้ปัญหาความขัดแย้งที่อาจเกิดขึ้นได้สองประการ: หนึ่ง (หรือทั้งสอง!) ของคำตอบเหล่านี้ไม่ถูกต้องหรือพวกเขาใช้การตีความที่แตกต่างกันของคำถาม ตัวอย่างเช่นฉันตีความ "หลังจากเด็คหมด" เพื่อหมายถึงหลังจากดูการ์ดใบสุดท้ายและหากอนุญาตให้อัปเดต "หมายเลขที่คุณจะอยู่" ก่อนที่จะยุติกระบวนการ น่าจะเป็นไปได้ว่าขั้นตอนสุดท้ายนั้นไม่ได้เกิดขึ้น บางทีการตีความที่แตกต่างกันเล็กน้อยเช่นนี้อาจอธิบายถึงความไม่เห็นด้วยซึ่งตอนนี้เราสามารถแก้ไขคำถามเพื่อให้ชัดเจนยิ่งขึ้นในสิ่งที่ถูกถาม

มีคำตอบที่แน่นอน (ในรูปแบบของผลิตภัณฑ์เมทริกซ์, นำเสนอในจุดที่ 4 ด้านล่าง) อัลกอริธึมที่มีประสิทธิภาพพอสมควรในการคำนวณมันเกิดขึ้นจากการสังเกตเหล่านี้:

1. การสุ่มแบบสุ่มของการ์ดสามารถสร้างขึ้นได้โดยการสุ่มไพ่แบบแล้วทำการสุ่มแยกไพ่ที่เหลือภายในสุ่มN $N+k$$N$$k$

2. ด้วยการสับเอซเพียงอย่างเดียวจากนั้น (ใช้การสังเกตครั้งแรก) สลับกับ twos จากนั้นทั้งสามและต่อ ๆ ไปปัญหานี้สามารถมองได้ว่าเป็นโซ่สิบสามขั้น

3. เราจำเป็นต้องติดตามมากกว่ามูลค่าของการ์ดที่เรากำลังค้นหา อย่างไรก็ตามในการทำเช่นนี้เราไม่จำเป็นต้องคำนึงถึงตำแหน่งของเครื่องหมายที่สัมพันธ์กับการ์ดทั้งหมดแต่จะมีเฉพาะตำแหน่งที่สัมพันธ์กับการ์ดที่มีค่าเท่ากันหรือเล็กกว่า

   ลองนึกภาพวางเครื่องหมายบนเอซตัวแรกแล้วทำเครื่องหมายสองอันแรกที่พบหลังจากนั้นเป็นต้น (หากในขั้นตอนใด ๆ ที่เด็คหมดโดยไม่ต้องแสดงการ์ดที่เรากำลังค้นหาเราจะปล่อยการ์ดทั้งหมดที่ไม่มีเครื่องหมาย) ให้ "สถานที่" ของเครื่องหมายแต่ละอัน (เมื่อมีอยู่) เป็นจำนวนไพ่ที่มีค่าเท่ากันหรือต่ำกว่า ถูกแจกเมื่อทำเครื่องหมาย (รวมถึงการ์ดที่ทำเครื่องหมายด้วยตัวเอง) สถานที่มีข้อมูลที่จำเป็นทั้งหมด

4. สถานที่หลังเครื่องหมายถูกสร้างขึ้นเป็นหมายเลขสุ่ม สำหรับสำรับที่กำหนดลำดับของสถานที่เหล่านี้ในรูปแบบกระบวนการสุ่ม อันที่จริงแล้วมันเป็นกระบวนการของมาร์คอฟ (พร้อมเมทริกซ์การเปลี่ยนแปลงตัวแปร) คำตอบที่แน่นอนสามารถคำนวณได้จากการคูณเมทริกซ์ที่สิบสอง$i^\text{th}$

การใช้แนวคิดเหล่านี้เครื่องนี้จะได้รับค่า (คำนวณในทศนิยมความแม่นยำสองเท่า) ในวินาที การประมาณค่าที่แน่นอนนี้ตัวเลขทุกตัวที่แสดงนั้นถูกต้อง1 / 9 $5.8325885529019965$$1/9$

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

ส่วนที่เหลือของโพสต์นี้ให้รายละเอียดนำเสนอการดำเนินงาน (ในR) และสรุปความคิดเห็นเกี่ยวกับคำถามและประสิทธิภาพของการแก้ปัญหา

---

การสร้างสับแบบสุ่มของสำรับ

จริง ๆ แล้วมันเป็นแนวคิดที่ชัดเจนและไม่มีความซับซ้อนทางคณิตศาสตร์มากนักในการพิจารณา "เด็ค" (aka multiset ) ของการ์ดซึ่งมีของนิกายที่ต่ำที่สุดของที่ต่ำที่สุดถัดไปและอื่น ๆ . (คำถามที่ถามเป็นความกังวลดาดฟ้ากำหนดโดยเวกเตอร์ .)k 1 k 2 13 ( 4 , 4 , … , 4 $N = k_1+k_2+\cdots+k_m$$k_1$$k_2$$13$$(4,4,\ldots,4)$

"สุ่มสุ่ม" ของการ์ดคือการเปลี่ยนรูปแบบหนึ่งครั้งที่สม่ำเสมอและสุ่มจากการเรียงสับเปลี่ยนของการ์ดshuffles เหล่านี้จัดอยู่ในกลุ่มของการกำหนดค่าที่เทียบเท่ากันเพราะการ "เอซ" ในหมู่พวกเขาไม่มีอะไรเปลี่ยนแปลงการ "twos" ในหมู่พวกเขาเองก็ไม่มีอะไรเปลี่ยนแปลงเช่นกัน ดังนั้นการเรียงสับเปลี่ยนแต่ละกลุ่มที่มีลักษณะเหมือนกันเมื่อชุดไพ่ถูกละเว้นจะมีพีชคณิต กลุ่มเหล่านี้ที่มีจำนวนจึงถูกกำหนดโดยสัมประสิทธิ์พหุนาม$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_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_m} ดังนั้นเราไม่ได้มองข้ามชุดค่าผสม นั่นหมายถึงกระบวนการเรียงลำดับของการสับไพ่อย่างถูกต้องจะตรวจจับความน่าจะเป็นของแต่ละชุดรวมกันโดยสมมติว่าในแต่ละขั้นตอนแต่ละวิธีที่เป็นไปได้ที่แตกต่างกันในการสลับไพ่ใหม่ในกลุ่มเก่านั้น$k_n$$\binom{N}{k_1,k_2,\ldots,k_m}$

กระบวนการสถานที่

เริ่มแรกมีเอซและเห็นได้ชัดว่ามีการทำเครื่องหมายครั้งแรก ในระยะต่อมาจะมีสถานที่ (หากมีการ์ดที่ทำเครื่องหมายไว้) เท่ากับ (ค่าบางส่วนจากถึง ) และเรากำลังจะกระจายไพ่รอบตัว เราสามารถเห็นภาพนี้ด้วยแผนภาพดังนี้$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}}$$

โดยที่ " " กำหนดสัญลักษณ์ที่ทำเครื่องหมายไว้ในปัจจุบัน ตามเงื่อนไขเกี่ยวกับค่าของตำแหน่งเราต้องการค้นหาความน่าจะเป็นที่ที่ถัดไปจะเท่ากับ (ค่าบางส่วนจากถึง ; ตามกฎของเกมสถานที่ถัดไปจะต้องมาหลังดังนั้น ) ถ้าเราสามารถหาวิธีการหลายวิธีมีการกระจายบัตรใหม่ในช่องว่างเพื่อให้สถานที่ถัดไปเท่ากับ ,แล้วเราสามารถหารด้วยจำนวนรวมของวิธีการที่จะกระจายบัตรเหล่านี้ (เท่ากับตามที่เราได้เห็น) เพื่อให้ได้$\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}}$$

แถบแนวตั้ง " " แสดงตำแหน่งที่มีการ์ดใหม่ใบแรกเกิดขึ้นหลังจากการ์ดที่ถูกทำเครื่องหมาย: จึงไม่มีการ์ดใหม่ปรากฏขึ้นระหว่างและ (ดังนั้นจึงไม่มีช่องแสดงในช่วงเวลานั้น) เราไม่ทราบว่าหลายดาวที่มีอยู่ในช่วงเวลานี้ดังนั้นฉันได้เพียงแค่เรียกมัน (ซึ่งอาจจะเป็นศูนย์) ไม่ทราบจะหายไปเมื่อเราพบความสัมพันธ์ระหว่างมันและQ$\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}$$

วิธีในการทำเช่นนี้ โปรดสังเกตว่า - นี่คือส่วนที่ยากที่สุดของการวิเคราะห์ - ที่ของเท่ากับเพราะ$\vert$$p+s+j+1$

• มีไพ่ "เก่า" ที่ก่อนหรือเครื่องหมาย$p$
• มีบัตรเก่าหลังจากทำเครื่องหมาย แต่ก่อน\$s$$\vert$
• มีบัตรใหม่ก่อนทำเครื่องหมาย$j$
• มีบัตรใหม่ที่แสดงโดยตัวเอง$\vert$

ดังนั้นทำให้เรามีข้อมูลเกี่ยวกับการเปลี่ยนแปลงจากสถานที่ที่ไปยังสถานที่ 1 เมื่อเราติดตามข้อมูลนี้อย่างละเอียดสำหรับค่าที่เป็นไปได้ทั้งหมดของและสรุปผลมากกว่าทุกเหล่านี้ (ไม่เป็นสมาชิกร่วม) เป็นไปได้ที่เราได้รับความน่าจะเป็นเงื่อนไขของสถานที่ต่อไปที่ ,$\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 = min ( k - 1 , q - ( p + 1 $j=\max(0, q-(n+1))$$j=\min(k-1, q-(p+1)$$n, k, q,$$p$

อัลกอริทึม

สมัยก่อนมีความน่าจะเป็นว่าสถานที่ที่จะเป็นและน่าจะเป็นมันจะมีค่าที่เป็นไปได้อื่น ๆ ในk_1 นี้สามารถแสดงโดยเวกเตอร์0)$1$$1$$0$$2, 3, \ldots, k_1$$p_1 = (1, 0, \ldots, 0)$

หลังจากสลับการ์ดถัดไปเวกเตอร์จะได้รับการอัปเดตเป็นโดยคูณ (ทางซ้าย) โดยเมทริกซ์การเปลี่ยนภาพk_2) สิ่งนี้จะทำซ้ำจนกว่าจะทั้งหมด ในขั้นตอนแต่ละผลรวมของรายการในความน่าจะเป็นเวกเตอร์เป็นโอกาสที่บางบัตรได้รับการทำเครื่องหมาย สิ่งที่ยังคงอยู่ที่จะทำให้ค่าเท่ากับดังนั้นจึงเป็นโอกาสที่ไม่มีบัตรถูกทำเครื่องหมายไว้หลังจากขั้นตอน$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มันคำนวณเมทริกซ์การเปลี่ยนแปลงและดำเนินการคูณ นอกจากนี้ยังดูแลการคำนวณเวกเตอร์เริ่มต้นหากอาร์กิวเมนต์เป็นเวกเตอร์เปล่า:$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

ตามกฎถ้าเป็นพระมหากษัตริย์ที่ถูกทำเครื่องหมายแล้วเราจะไม่มองหาบัตรใด ๆ เพิ่มเติม: ที่นี้หมายถึงค่าของจะต้องมีการเพิ่มขึ้นถึง1เมื่อทำเช่นนั้นความแตกต่างจะให้การกระจายของ "หมายเลขที่คุณจะได้รับเมื่อเด็คหมด":$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

(เปรียบเทียบสิ่งนี้กับผลลัพธ์ที่ฉันรายงานในคำตอบแยกต่างหากที่อธิบายถึงการจำลอง Monte-Carlo: พวกเขาดูเหมือนจะเหมือนกันมากถึงความคาดหวังของการเปลี่ยนแปลงแบบสุ่ม)

มูลค่าที่คาดว่าจะได้ทันที:

> 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ในสารานุกรมออนไลน์ของลำดับจำนวนเต็ม ดังนั้นเราอาจหวังว่าสูตรปิดสำหรับเด็คที่มีค่าคงที่ ( "เหมาะ") ที่จะพูดคุยลำดับนี้ซึ่งตัวมันเองมีความหมายที่ลึกซึ้งบางอย่าง (ยกตัวอย่างเช่นมันนับขนาดของชั้นเรียน conjugacy ที่ใหญ่ที่สุดในกลุ่มการเปลี่ยนแปลงและยังเกี่ยวข้องกับค่าสัมประสิทธิ์ Trinomial .) ( แต่น่าเสียดายที่ส่วนกลับในลักษณะทั่วไปสำหรับมักจะไม่จำนวนเต็ม.)$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 ม. 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})$

การใช้งานหนึ่งใน asymptotics เหล่านี้คือการคำนวณเวลาของโครงการสำหรับปัญหาที่ใหญ่กว่า ตัวอย่างเช่นเมื่อเห็นว่ากรณีใช้เวลาประมาณวินาทีเราจะประมาณว่ากรณี (น่าสนใจมาก)จะใช้เวลาประมาณวินาที (ใช้เวลาจริงวินาที)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$

Hacked ง่าย Monte Carlo ใน Perl และพบว่าประมาณ5.8329$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];
    }
}