Xác suất vẽ một từ đã cho từ một túi chữ cái trong Scrabble

Giả sử bạn có một cái túi có gạch, mỗi cái có một chữ cái trên đó. Có các gạch có chữ 'A', với 'B', v.v. và gạch 'wildcard' (chúng ta có ). Giả sử bạn đã có một từ điển với số lượng từ hữu hạn.$n$$n_A$$n_B$$n_*$$n = n_A + n_B + \ldots + n_Z + n_*$

Bạn chọn gạch từ túi mà không cần thay thế.$k$

Làm thế nào bạn sẽ tính toán (hoặc ước tính) xác suất mà bạn có thể tạo thành một từ nhất định, có độ dài (với 1 < = < ) từ từ điển cho các ô được chọn?$l$$l$$k$$k$

Đối với những người không quen thuộc với Scrabble (TM), ký tự đại diện có thể được sử dụng để khớp với bất kỳ chữ cái nào. Do đó, từ 'BOOT' có thể được 'đánh vần' với các ô 'B', '*', 'O', 'T'. Thứ tự mà các chữ cái được vẽ không quan trọng.

Gợi ý: để đơn giản hóa việc viết câu trả lời, tốt hơn hết là bạn chỉ cần trả lời câu hỏi: xác suất có từ 'BOOT' trong số các động thái có thể của bạn sau khi rút 7 chữ cái từ một túi mới.

(phần giới thiệu của vấn đề đã được sao chép từ câu hỏi tương tự này )

Một công thức được yêu cầu. Thật không may, tình hình phức tạp đến nỗi dường như bất kỳ công thức nào cũng sẽ chỉ là một cách làm tròn để liệt kê tất cả các khả năng. Thay vào đó, câu trả lời này đưa ra một thuật toán (a) tương đương với một công thức liên quan đến tổng các sản phẩm của các hệ số nhị thức và (b) có thể được chuyển sang nhiều nền tảng.

---

Để có được công thức như vậy, hãy chia các khả năng thành các nhóm tách rời nhau theo hai cách: theo số lượng chữ không có trong từ được chọn trong giá (hãy để nó là ) và theo số lượng ký tự đại diện (khoảng trống) được chọn ( hãy để nó là w ). Khi có r = 7 gạch trong giá, N gạch có sẵn, M gạch có sẵn với các chữ cái không có trong từ và W = 2 khoảng trống có sẵn, số lượng lựa chọn có thể được đưa ra bởi ( m , w ) là$m$$w$$r=7$$N$$M$$W=2$$(m,w)$

$$\binom{M}{m}\binom{W}{w}\binom{N-M-W}{r-m-w}$$

bởi vì các lựa chọn của chữ cái không chữ, khoảng trắng và chữ cái là điều kiện độc lập trên$(m,w,r).$

Điều này làm giảm vấn đề để tìm ra nhiều cách đánh vần một từ khi chỉ chọn từ gạch đại diện cho chữ của văn bản, cho rằng khoảng trống có sẵn và gạch sẽ được chọn. Tình hình là lộn xộn và dường như không có công thức đóng. Chẳng hạn, với các khoảng trống và chữ cái được rút ra, sẽ có chính xác bốn chữ cái còn lại để đánh vần "boot" được rút ra từ các ô "b", "o" và "t" . Cho có "b", "o" và$w$$r-m-w$$w=0$$m=3$$2$$8$$6$"t" trong bộ gạch Scrabble, có xác suất dương của bản vẽ (multisets) "bboo", "bbot", "bbtt", "booo", "boot", "chai", "bttt", "oooo "," ooot "," oott "," ottt "và" tttt ", nhưng chỉ một trong những phép thuật này" khởi động ". Và đó là trường hợp dễ dàng! Ví dụ: giả sử giá đỡ chứa năm ô được chọn ngẫu nhiên từ các ô "o", "b" và "t", cùng với cả hai ô trống, có nhiều cách khác để đánh vần "khởi động" - và không đánh vần nó. Ví dụ: "boot" có thể được đánh vần từ "__boott" và "__bbttt", nhưng không phải từ "__ttttt".

Tính này - trọng tâm của vấn đề - có thể được xử lý đệ quy. Tôi sẽ mô tả nó với một ví dụ. Giả sử chúng ta muốn đếm các cách đánh vần "boot" bằng một ô trống và bốn ô khác từ bộ sưu tập các ô "b", "o" và "t" (hai ô còn lại hiển thị các chữ cái không trống không có trong { "người máy"}). Hãy xem xét chữ cái đầu tiên, "b":

1. Một "b" có thể được rút ra theo cách từ hai ô "b" có sẵn. Điều này giúp giảm vấn đề đếm số cách đánh vần hậu tố "oot" bằng cả hai khoảng trống và chỉ ba gạch nữa từ bộ sưu tập gạch "o" và "t".$\binom{2}{1}$

2. Một khoảng trống có thể được chỉ định là "b". Điều này giúp giảm vấn đề đếm số cách đánh vần "oot" bằng cách sử dụng khoảng trống còn lại và chỉ thêm ba ô nữa từ bộ sưu tập các ô "o" và "t".

Nói chung, các bước (1) và (2) - không khớp nhau và do đó đóng góp bổ sung cho các tính toán xác suất - có thể được thực hiện như một vòng lặp trên số lượng khoảng trống có thể được sử dụng cho chữ cái đầu tiên. Các vấn đề giảm được giải quyết đệ quy. Trường hợp cơ sở xảy ra khi còn một chữ cái, có một số ô nhất định có sẵn chữ cái đó và cũng có thể có một số khoảng trống trong giá. Chúng tôi chỉ phải đảm bảo rằng số lượng khoảng trống trong giá cộng với số lượng gạch có sẵn sẽ đủ để có được số lượng mong muốn của chữ cái cuối cùng đó.

Đây là Rmã cho bước đệ quy. rackthường bằng , là một mảng đếm các chữ cái (chẳng hạn như ), là một cấu trúc tương tự cho số lượng gạch có sẵn với các chữ cái đó và là số lượng khoảng trống được giả sử xảy ra trong giá.$7$wordc(b=1, o=2, t=1)alphabetwild

f <- function(rack, word, alphabet, wild) {
  if (length(word) == 1) {
    return(ifelse(word > rack+wild, 0, choose(alphabet, rack)))
  }
  n <- word[1]
  if (n <= 0) return(0)
  m <- alphabet[1]
  x <- sapply(max(0, n-wild):min(m, rack), 
              function(i) {
                choose(m, i) * f(rack-i, word[-1], alphabet[-1], wild-max(0, n-i))
              })
  return(sum(x))
}

Một giao diện cho chức năng này chỉ định các ô xếp Scrabble tiêu chuẩn, chuyển đổi một từ đã cho thành cấu trúc dữ liệu nhiều trang của nó và thực hiện tổng hai lần trên và . Đây là nơi các hệ số nhị thức và được tính toán và nhân lên.$m$$w$$\binom{M}{m}$$\binom{W}{w}$

scrabble <- function(sword, n.wild=2, rack=7, 
              alphabet=c(a=9,b=2,c=2,d=4,e=12,f=2,g=3,h=2,i=9,j=1,k=1,l=4,m=2,
                         n=6,o=8,p=2,q=1,r=6,s=4,t=6,u=4,v=2,w=2,x=1,y=2,z=1),
              N=sum(alphabet)+n.wild) {
  word = sort(table(strsplit(sword, NULL))) # Sorting speeds things a little
  a <- sapply(names(word), function(s) alphabet[s])
  names(a) <- names(word)
  x <- sapply(0:n.wild, function(w) {
    sapply(sum(word):rack-w, 
           function(i) {
             f(i, word, a, wild=w) *
               choose(n.wild, w) * choose(N-n.wild-sum(a), rack-w-i)
           })
  })
  return(list(numerator = sum(x), denominator = choose(N, rack),
              value=sum(x) / choose(N, rack)))
}

---

Chúng ta hãy thử giải pháp này và thời gian khi chúng ta đi. Thử nghiệm sau đây sử dụng cùng các đầu vào được sử dụng trong các mô phỏng của @Rasmus Bååth :

system.time(x <- sapply(c("boot", "red", "axe", "zoology"), scrabble))

Máy này báo cáo tổng thời gian giây: nhanh chóng hợp lý. Kết quả?$0.05$

> x
            boot        red         axe         zoology     
numerator   114327888   1249373480  823897928   11840       
denominator 16007560800 16007560800 16007560800 16007560800 
value       0.007142118 0.07804896  0.0514693   7.396505e-07

Xác suất "khởi động" là chính xác bằng giá trị trong câu trả lời khác của tôi (sử dụng một phương pháp tương tự nhưng đặt nó trong một khung mạnh hơn đòi hỏi nền tảng tính toán đại số tượng trưng). Xác suất của cả bốn từ gần hợp lý với mô phỏng của Bååth (không thể dự đoán sẽ mang lại giá trị chính xác cho "động vật học" do xác suất thấp là ít hơn một phần triệu).$114327888/16007560800$$2381831/333490850$$11840/16007560800,$

Các câu trả lời cho câu hỏi được tham chiếu áp dụng trực tiếp tại đây: tạo một từ điển chỉ bao gồm từ đích (và cách viết ký tự đại diện có thể có của nó), tính toán khả năng một giá ngẫu nhiên không thể tạo thành mục tiêu và trừ từ . Tính toán này là nhanh chóng.$1$

Mô phỏng (hiển thị ở cuối) hỗ trợ các câu trả lời được tính toán.

---

Chi tiết

Như trong câu trả lời trước, Mathicala được sử dụng để thực hiện các phép tính.

1. Chỉ định vấn đề: từ (hoặc từ, nếu bạn thích), các chữ cái, số đếm của chúng và kích thước giá đỡ. Bởi vì tất cả các chữ cái không có trong từ đều hoạt động giống nhau, nó tăng tốc độ tính toán để thay thế tất cả chúng bằng một ký hiệu duy nhất đại diện cho "bất kỳ chữ cái nào không có trong từ".$\chi$

   word = {b, o, o, t};
   letters = {b, o, t, \[Chi], \[Psi]};
   tileCounts = {2, 8, 6, 82, 2};
   rack = 7;

2. Tạo một từ điển của từ này (hoặc từ) và gia tăng nó để bao gồm tất cả các cách viết ký tự đại diện có thể.

   dict[words_, nWild_Integer] := Module[{wildcard, w},
      wildcard = {xx___, _, yy___} -> {xx, \[Psi], yy};
      w = Nest[Flatten[ReplaceList[#, wildcard] & /@ #, 1] &, words, nWild];
      Union[Times @@@ Join[w, Times @@@ words]]];
   dictionary = dict[{word}, 2]

   $\left\{b o^2 t, b o^2 \psi ,b o t \psi ,o^2 t \psi ,b o \psi ^2,o^2 \psi ^2,b t \psi ^2,o t \psi ^2\right\}$

3. Tính toán các từ khóa:

   alphabet = Plus @@ letters;
   nonwords = Nest[PolynomialMod[# alphabet, dictionary] &, 1, rack]

   $b^7 + 7 b^6 o + 21 b^5 o^2 + \cdots +7 \chi \psi ^6+\psi ^7$

   $185$

4. Tính toán các cơ hội. Để lấy mẫu bằng thay thế, chỉ cần thay thế số lượng gạch cho các biến:

   chances = (Transpose[{letters, tileCounts/(Plus @@ tileCounts)}] /. {a_, b_} -> a -> b);
   q = nonwords /. chances;
   1 - q

   $\frac{207263413}{39062500000}$

   $0.00756036.$

   Để lấy mẫu mà không thay thế, sử dụng quyền hạn giai thừa thay vì quyền hạn:

   multiplicities = MapThread[Rule, {letters, tileCounts}];
   chance[m_] :=  (ReplaceRepeated[m , Power[xx_, n_] -> FactorialPower[xx, n]] 
                  /. multiplicities);
   histor = chance /@ MonomialList[nonwords];
   q0 = Plus @@ histor  / FactorialPower[Total[tiles], nn];
   1 - q0

   $\frac{2381831}{333490850}$

   $0.00714212.$

---

Kết quả mô phỏng

$10^6$

simulation = RandomChoice[tiles -> letters, {10^6, 7}];
u = Tally[Times @@@ simulation];
(p = Total[Cases[Join[{PolynomialMod[u[[All, 1]], dictionary]}\[Transpose], 
       u, 2], {0, _, a_} :> a]] / Length[simulation] ) // N

$0.007438$

So sánh nó với giá trị được tính toán liên quan đến lỗi tiêu chuẩn của nó:

(p - (1 - q)) / Sqrt[q (1 - q) / Length[simulation]] // N

$-1.41259$

Thỏa thuận là tốt, hỗ trợ mạnh mẽ cho kết quả tính toán.

$10^6$

tilesAll = Flatten[MapThread[ConstantArray[#1, #2] &, {letters, tiles}] ]
    (p - (1 - q)) / Sqrt[q (1 - q) / Length[simulation]] // N;
simulation = Table[RandomSample[tilesAll, 7], {i, 1, 10^6}];
u = Tally[Times @@@ simulation];
(p0 = Total[Cases[Join[{PolynomialMod[u[[All, 1]], dictionary]}\[Transpose], 
       u, 2], {0, _, a_} :> a]] / Length[simulation] ) // N

$0.00717$

Hãy so sánh:

(p0 - (1 - q0)) / Sqrt[q0 (1 - q0) / Length[simulation]] // N

$0.331106$

Các thỏa thuận trong mô phỏng này là tuyệt vời.

$12$

Vì vậy, đây là một giải pháp Monte Carlo , nghĩa là chúng ta sẽ mô phỏng việc vẽ các viên gạch hàng trăm lần và sau đó chúng ta sẽ tính toán có bao nhiêu trong số các bản vẽ mô phỏng này dẫn đến việc chúng ta có thể tạo thành từ đã cho. Tôi đã viết giải pháp bằng R, nhưng bạn có thể sử dụng bất kỳ ngôn ngữ lập trình nào khác, nói Python hoặc Ruby.

Trước tiên tôi sẽ mô tả cách mô phỏng một lần vẽ. Trước tiên hãy xác định tần số gạch.

# The tile frequency used in English Scrabble, using "_" for blank.
tile_freq <- c(2, 9 ,2 ,2 ,4 ,12,2 ,3 ,2 ,9 ,1 ,1 ,4 ,2 ,6 ,8 ,2 ,1 ,6 ,4 ,6 ,4 ,2 ,2 ,1 ,2 ,1)
tile_names <- as.factor(c("_", letters))
tiles <- rep(tile_names, tile_freq)
## [1] _ _ a a a a a a a a a b b c c d d d d e e e e e e
## [26] e e e e e e f f g g g h h i i i i i i i i i j k l
## [51] l l l m m n n n n n n o o o o o o o o p p q r r r
## [76] r r r s s s s t t t t t t u u u u v v w w x y y z
## 27 Levels: _ a b c d e f g h i j k l m n o p q r ... z

Sau đó mã hóa từ dưới dạng một vectơ đếm chữ.

word <- "boot"
# A vector of the counts of the letters in the word
word_vector <- table( factor(strsplit(word, "")[[1]], levels=tile_names))
## _ a b c d e f g h i j k l m n o p q r s t u v w x y z 
## 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 1 0 0 0 0 0 0 

Bây giờ, vẽ một mẫu gồm bảy ô và mã hóa chúng theo cùng một cách với từ đó.

tile_sample <- table(sample(tiles, size=7))
## _ a b c d e f g h i j k l m n o p q r s t u v w x y z 
## 1 0 0 0 0 1 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 1 0 1 0 0 0 

Cuối cùng, tính toán những chữ cái còn thiếu ...

missing <- word_vector - tile_sample
missing <- ifelse(missing < 0, 0, missing)
## _ a b c d e f g h i j k l m n o p q r s t u v w x y z 
## 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 

... Và tổng số chữ cái còn thiếu và trừ đi số lượng khoảng trống có sẵn. Nếu kết quả bằng 0 hoặc ít hơn, chúng tôi đã thành công trong việc đánh vần từ đó.

sum(missing) - tile_sample["blank"] <= 0
## FALSE

Trong trường hợp cụ thể này, chúng tôi đã không ... Bây giờ chúng tôi chỉ cần lặp lại điều này nhiều lần và tính tỷ lệ phần trăm rút thăm thành công. Tất cả điều này được thực hiện bởi hàm R sau:

word_prob <- function(word, reps = 50000) {
  tile_freq <- c(2, 9 ,2 ,2 ,4 ,12,2 ,3 ,2 ,9 ,1 ,1 ,4 ,2 ,6 ,8 ,2 ,1 ,6 ,4 ,6 ,4 ,2 ,2 ,1 ,2 ,1)
  tile_names <- as.factor(c("_", letters))
  tiles <- rep(tile_names, tile_freq)
  word_vector <- table( factor(strsplit(word, "")[[1]], levels=tile_names))
  successful_draws <- replicate(reps, {
    tile_sample <- table(sample(tiles, size=7))
    missing <- word_vector - tile_sample
    missing <- ifelse(missing < 0, 0, missing)
    sum(missing) - tile_sample["_"] <= 0
  })
  mean(successful_draws)
}

Dưới đây repslà số lượng rút thăm mô phỏng. Bây giờ chúng ta có thể thử nó trên một số từ khác nhau.

> word_prob("boot")
[1] 0.0072
> word_prob("red")
[1] 0.07716
> word_prob("axe")
[1] 0.05088
> word_prob("zoology")
[1] 2e-05

$$p_0=\frac{\binom{n_b}{1}\binom{n_o}{2}\binom{n_t}{1}\binom{n-4}{3}}{\binom{n}{7}}$$ $p_k$$k$ $$\begin{eqnarray*} p_0&=&\frac{\binom{n_b}{1}\binom{n_o}{2}\binom{n_t}{1}\binom{n-4}{3}}{\binom{n}{7}} \\ p_1&=&p_0 +\frac{\binom{n_*}{1}\binom{n_o}{2}\binom{n_t}{1}\binom{n-4}{3}}{\binom{n}{7}} + \frac{\binom{n_b}{1}\binom{n_o}{1}\binom{n_*}{1}\binom{n_t}{1}\binom{n-4}{3}}{\binom{n}{7}} + \frac{\binom{n_b}{1}\binom{n_o}{2}\binom{n_*}{1}\binom{n-4}{3}}{\binom{n}{7}}\\ &=&p_0 +\frac{\binom{n_*}{1}\binom{n-4}{3}}{\binom{n}{7}}(\binom{n_o}{2}\binom{n_t}{1} + \binom{n_b}{1}\binom{n_o}{1}\binom{n_t}{1} + \binom{n_b}{1}\binom{n_o}{2})\\ p_2&=&p_1 + \frac{\binom{n_*}{2}\binom{n-4}{3}}{\binom{n}{7}}(\binom{n_b}{1}\binom{n_o}{1} + \binom{n_b}{1}\binom{n_t}{1} + \binom{n_o}{2} + \binom{n_o}{1}\binom{n_t}{1})\\ p_3&=&p_2 + \frac{\binom{n_*}{3}\binom{n-4}{3}}{\binom{n}{7}}(\binom{n_b}{1} + \binom{n_o}{1} + \binom{n_t}{1})\\ p_4&=&p_3 + \frac{\binom{n_*}{4}\binom{n-4}{3}}{\binom{n}{7}}\\ p_i&=&p_4, i\ge4 \end{eqnarray*}$$

Meh.

$$\frac{\partial \gamma}{\partial c} = b_0x^c ln(x) \sum_{r=0}^{\infty}\frac{(c+y-1)(c+\alpha)_r(c+\beta)_r}{(c+1)_r(c+\gamma)_r}x^r+$$

$$+b_0x^c\sum_{r=0}^{\infty}\frac{(c+\gamma-1)(c+\alpha)_r(c+\beta)_r}{(c+1)_r(c+\gamma)_r}(\frac{1}{c+\gamma-1}+$$

$$+\sum_{k=0}^{r-1}(\frac{1}{c+\alpha+\kappa}+\frac{1}{c+\beta+\kappa}+\frac{1}{c+1+\kappa}-\frac{1}{c+\gamma+\kappa}))x^r$$

$$=b_0x^c\sum_{r=0}^{\infty}\frac{(c+\gamma-1)(c+\alpha)_r(c+\beta)_r}{(c+1)_r(c+\gamma)_r}(ln \ x+\frac{1}{c+\gamma-1}+$$

$$+\sum_{k=0}^{r-1}(\frac{1}{c+\alpha+\kappa}+\frac{1}{c+\beta+\kappa}-\frac{1}{c+1+\kappa}-\frac{1}{c+\gamma+\kappa}))x^r$$ .

It's been a while since I looked at how I built my project. And my math may be entirely incorrect below, or correct. I may have it backwards. Honestly, I forget. BUT! Using only binomial combination, without taking into account blank tiles which throws the entire thing out of whack. The simple combination solution without wild.

I asked these questions myself, and built my own scrabble words probability dictionary because of it. You don't need a dictionary of possible words pulled out, only the math behind it and available letters based on letters in tile bag. The array of English rules is below. I spent weeks developing the math just to answer this question for all English words that can be used in a game, including words that can not be used in a game. It may all be incorrect.

The probability of drawing a given word from a bag of letters in Scrabble, requires how many letters are available in the bag, for each letter ( A-Z ) and, whether we're using the wild card as an addition to the math. The blank tiles are included in this math - assuming 100 tiles, 2 of which are blank. Also, how many tiles are available differs based on language of the game, and game rules from around the world. English scrabble differs from Arabic scrabble, obviously. Just alter the available letters, and the math should do the work.

If anyone finds errors, I will be sure to update and resolve them.

Boot: The probability of Boot in a game of scrabble is 0.000386% which is a chance of 67 out of 173,758 hands as shown on the word page for boot.

English Tiles

all is the array of letters in the bag. count is the array of available tiles for that letter, and point is the point value of the letter.

// All arranged by letter, number of letters in scrabble game, and point for the letter.
$all = array("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z");
    $count = array("9", "2", "2", "4", "12", "2", "3", "2", "9", "1", "1", "4", "2", "6", "8", "2", "1", "6", "4", "6", "4", "2", "2", "1", "2", "1");
$point = array("1", "3", "3", "2", "1", "4", "2", "4", "1", "8", "5", "1", "3", "1", "1", "3", "10", "1", "1", "1", "1", "4", "4", "8", "4", "10");

There are 100 tiles in an English scrabble game (i.e., the sum of $count). It does not matter how the tiles are pulled, so it's not a permutation.

The Math I Used Determine how many letters are in the word and what letters are in the word, how many of those letters are available in the tile bag ( count for each letter, unique and allchars ). Binomial coefficient of each, divided by binomial coefficient of length word.

Determine the binomial combinations available

let C(n,r) be binomial coefficient: n!/[n!(n-r)!], or 0 if r > n

Foreach letter, what is the binomial coefficient.

There is 1 "B". There are 2 available, a 2% chance of pulling the b.
There is 2 "O". There are 8 available, a 8% chance of pulling the o.
There is 1 "T". There are 6 available, a 6% chance of pulling the t.
BOOT is a 4 letter word, being taken from a 100 tile set with blanks, 98 without.

n = 98. The number of tiles without blank in the English set

$B = {2 \choose 1} = \frac{2!}{2!(2-1)!}$
$O = {8 \choose 2} = \frac{8!}{8!(8-2)!}$
$T = {6 \choose 1} = \frac{6!}{6!(6-1)!}$

${B \times O \times T}$ divided by the binomial coefficient of tilecount $\frac{98!}{98!(98-{\rm length})!}$