Kemungkinan menggambar kata yang diberikan dari kantong surat di Scrabble

Misalkan Anda memiliki tas dengan $n$ ubin, masing-masing dengan huruf di atasnya. Ada $n_A$ ubin dengan huruf 'A', $n_B$ dengan 'B', dan seterusnya, dan $n_*$ ubin wildcard '(kami memiliki ). Misalkan Anda memiliki kamus dengan jumlah kata yang terbatas.$n = n_A + n_B + \ldots + n_Z + n_*$

Anda memilih ubin dari kantong tanpa pengganti.$k$

Bagaimana Anda menghitung (atau memperkirakan) probabilitas bahwa Anda dapat membentuk kata tertentu, dengan panjang (dengan 1 < = < ) dari kamus mengingat ubin dipilih?l k $l$$l$$k$$k$

Bagi mereka yang tidak terbiasa dengan Scrabble (TM), karakter wildcard dapat digunakan untuk mencocokkan huruf apa pun. Jadi kata 'BOOT' bisa 'dieja' dengan ubin 'B', '*', 'O', 'T'. Urutan pengambilan surat tidak menjadi masalah.

Saran: untuk menyederhanakan penulisan jawaban, mungkin lebih baik hanya menjawab pertanyaan: berapa probabilitas memiliki kata 'BOOT' di antara kemungkinan perpindahan Anda setelah menggambar 7 huruf dari tas baru.

(pengantar masalah telah disalin dari pertanyaan serupa ini )

Sebuah rumus diminta. Sayangnya, situasinya sangat rumit sehingga tampaknya formula apa pun hanya akan menjadi jalan memutar untuk menyebutkan semua kemungkinan. Alih-alih, jawaban ini menawarkan algoritma yang (a) sama dengan formula yang melibatkan jumlah produk dari koefisien binomial dan (b) dapat diangkut ke banyak platform.

---

Untuk mendapatkan formula seperti itu, bagi kemungkinan menjadi kelompok-kelompok yang saling terpisah dalam dua cara: menurut berapa banyak huruf tidak dalam kata yang dipilih di rak (biarkan ini $m$ ) dan menurut berapa banyak wildcard (kosong) yang dipilih ( biarkan ini $w$ ). Ketika ada $r=7$ petak di rak, $N$ petak tersedia, $M$ petak tersedia dengan huruf tidak ada dalam kata, dan $W=2$ kosong tersedia, jumlah pilihan yang mungkin diberikan oleh $(m,w)$ adalah

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

karena pilihan huruf non-kata, kosong, dan kata-kata bersyarat independen pada $(m,w,r).$

Ini mengurangi masalah untuk menemukan sejumlah cara untuk mengeja kata ketika memilih hanya dari petak yang mewakili huruf kata, mengingat bahwa kosong tersedia dan r - m - w petak akan dipilih. Situasinya berantakan dan tidak ada formula tertutup yang tersedia. Misalnya, dengan w = 0 kosong dan m = 3 huruf di luar kata ditarik, akan ada empat huruf tersisa untuk mengeja "boot" yang diambil dari ubin "b", "o", dan "t" . Mengingat ada 2 "b", 8 "o", dan $w$$r-m-w$$w=0$$m=3$$2$$8$$6$"t" ada di set ubin Scrabble, ada kemungkinan positif menggambar (multiset) "bboo", "bbot", "bbtt", "booo", "boot", "bott", "bttt", "oooo "," ooot "," oott "," ottt ", dan" tttt ", tetapi hanya satu dari mantra ini" boot ". Dan itu adalah kasus yang mudah! Misalnya, seandainya rak berisi lima ubin yang dipilih secara acak dari ubin "o", "b", dan "t", bersama dengan keduanya, ada banyak lagi cara untuk mengeja "boot" - dan bukan mengeja. Misalnya, "boot" dapat dieja dari "__boott" dan "__bbttt", tetapi tidak dari "__ttttt".

Penghitungan ini - inti dari masalah - dapat ditangani secara rekursif. Saya akan menggambarkannya dengan sebuah contoh. Misalkan kita ingin menghitung cara mengeja "boot" dengan satu ubin kosong dan empat ubin lagi dari koleksi ubin "b", "o", dan "t" (di mana dua ubin yang tersisa menunjukkan huruf-huruf tidak kosong yang tidak dalam { "b", "o", "t"}). Pertimbangkan huruf pertama, "b":

1. A "b" dapat ditarik ke dalam cara dari dua ubin "b" yang tersedia. Ini mengurangi masalah untuk menghitung jumlah cara mengeja akhiran "oot" menggunakan kedua kosong dan hanya tiga ubin lagi dari koleksi ubin "o" dan "t".$\binom{2}{1}$

2. Satu kosong dapat ditetapkan sebagai "b". Ini mengurangi masalah untuk menghitung jumlah cara mengeja "oot" menggunakan kosong yang tersisa dan hanya tiga ubin lagi dari koleksi ubin "o" dan "t".

Secara umum, langkah (1) dan (2) - yang terpisah dan karena itu berkontribusi secara positif pada perhitungan probabilitas - dapat diimplementasikan sebagai loop atas kemungkinan jumlah kosong yang mungkin digunakan untuk huruf pertama. Pengurangan masalah diselesaikan secara rekursif. Kasing dasar terjadi ketika ada satu huruf tersisa, ada sejumlah ubin dengan surat itu tersedia, dan mungkin ada beberapa kosong di rak juga. Kami hanya perlu memastikan bahwa jumlah kosong di rak ditambah jumlah ubin yang tersedia akan cukup untuk mendapatkan jumlah yang diinginkan dari surat terakhir.

Berikut ini adalah Rkode untuk langkah rekursif. rackbiasanya sama ,adalah array jumlah huruf (seperti),adalah struktur yang sama memberikan jumlah ubin yang tersedia dengan huruf-huruf itu, danjumlah kosong yang diasumsikan terjadi di rak.$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))
}

Antarmuka untuk fungsi ini menentukan ubin Scrabble standar, mengubah kata yang diberikan ke dalam struktur data multisetnya, dan melakukan jumlah ganda di atas dan w . Di sinilah koefisien binomial$m$$w$ dan ($\binom{M}{m}$ dihitung dan dikalikan.$\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)))
}

---

Mari kita coba solusi ini dan tentukan waktunya. Tes berikut menggunakan input yang sama yang digunakan dalam simulasi oleh @Rasmus Bååth :

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

Mesin ini melaporkan total waktu berlalu detik: cukup cepat. Hasil?$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

Probabilitas untuk "boot" dari persis sama dengan nilai 2381831 / 333490850 diperoleh dalam jawaban saya yang lain (yang menggunakan metode yang sama tapi sofa itu dalam kerangka yang lebih kuat membutuhkan platform aljabar komputasi simbolik). Probabilitas untuk semua empat kata yang cukup dekat dengan simulasi Baath (yang tidak bisa diharapkan untuk memberikan nilai yang akurat untuk "zoologi" karena probabilitas rendah dari 11840 / 16007560800 , yang kurang dari satu dalam satu juta).$114327888/16007560800$$2381831/333490850$$11840/16007560800,$

Jawaban untuk pertanyaan yang direferensikan berlaku di sini secara langsung: buat kamus yang hanya terdiri dari kata target (dan kemungkinan ejaan wildcardnya), hitung kemungkinan rak acak tidak dapat membentuk target, dan kurangi dari . Perhitungan ini cepat.$1$

Simulasi (ditampilkan di bagian akhir) mendukung jawaban yang dihitung.

---

Detail

Seperti pada jawaban sebelumnya, Mathematica digunakan untuk melakukan perhitungan.

1. Tentukan masalah: kata (atau kata-kata, jika Anda suka), huruf, jumlah mereka, dan ukuran rak. Karena semua huruf yang tidak ada dalam kata tersebut bertindak sama, itu sangat mempercepat perhitungan untuk menggantinya dengan simbol tunggal mewakili "huruf apa pun yang tidak ada dalam kata."$\chi$

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

2. Buat kamus kata ini (atau kata-kata) dan tambahkan untuk memasukkan semua ejaan wildcard yang mungkin.

   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. Hitung bukan kata-kata:

   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$

   (Ada $185$ non-kata dalam kasus ini.)

4. Hitung peluangnya. Untuk pengambilan sampel dengan penggantian, ganti saja jumlah ubin untuk variabel:

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

   $\frac{207263413}{39062500000}$

   Nilai ini sekitar $0.00756036.$

   Untuk pengambilan sampel tanpa penggantian, gunakan kekuatan faktorial alih-alih kekuatan:

   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}$

   Nilai ini sekitar Perhitungannya praktis instan.$0.00714212.$

---

Hasil simulasi

Hasil dari iterasi dengan penggantian:$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$

Bandingkan dengan nilai yang dihitung relatif terhadap kesalahan standar:

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

$-1.41259$

Perjanjian baik-baik saja, sangat mendukung hasil yang dihitung.

$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$

Buat perbandingan:

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

$0.331106$

Kesepakatan dalam simulasi ini sangat bagus.

$12$

Jadi ini Monte Carlo , yaitu, kita akan mensimulasikan menggambar ubin jutaan kali dan kemudian kita akan menghitung berapa banyak undian yang disimulasikan menghasilkan kita mampu membentuk kata yang diberikan. Saya telah menulis solusinya dalam R, tetapi Anda bisa menggunakan bahasa pemrograman lain, misalnya Python atau Ruby.

Saya pertama-tama akan menjelaskan cara mensimulasikan satu undian. Pertama mari kita tentukan frekuensi ubin.

# 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

Kemudian mengkodekan kata sebagai vektor jumlah huruf.

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 

Sekarang gambar sampel tujuh ubin dan encode dengan cara yang sama seperti kata.

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 

Akhirnya, hitung huruf apa yang hilang ...

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 

... dan jumlahkan jumlah huruf yang hilang dan kurangi jumlah kosong yang tersedia. Jika hasilnya nol atau kurang, kami berhasil mengeja kata.

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

Namun dalam kasus khusus ini kami tidak ... Sekarang kami hanya perlu mengulanginya berkali-kali dan menghitung persentase pengundian yang berhasil. Semua ini dilakukan oleh fungsi R berikut:

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

Ini repsadalah jumlah undian yang disimulasikan. Sekarang kita dapat mencobanya pada sejumlah kata yang berbeda.

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

For the word "BOOT" with no wildcards:

$$p_0=\frac{\binom{n_b}{1}\binom{n_o}{2}\binom{n_t}{1}\binom{n-4}{3}}{\binom{n}{7}}$$ With wildcards, it becomes more tedious. Let $p_k$ indicate the probability of being able to play "BOOT" with $k$ wildcards: $$\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})!}$