Probabilità di trarre una determinata parola da un sacco di lettere in Scrabble

Supponi di avere una borsa con tessere, ognuna con una lettera. Ci sono tessere con la lettera 'A', con 'B' e così via, e tessere 'jolly' (abbiamo ). Supponiamo di avere un dizionario con un numero finito di parole.n A n B n ∗ n = n A + n B + … + n Z + n $n$$n_A$$n_B$$n_*$$n = n_A + n_B + \ldots + n_Z + n_*$

Scegli piastrelle dalla borsa senza sostituzione.$k$

Come calcoleresti (o stimerai) la probabilità che tu possa formare una determinata parola, di lunghezza (con 1 < l = < k ) dal dizionario date le k tessere selezionate?l k $l$$l$$k$$k$

Per coloro che non hanno familiarità con Scrabble (TM), il carattere jolly può essere utilizzato per abbinare qualsiasi lettera. Pertanto, la parola "STIVALE" potrebbe essere "digitata" con le tessere "B", "*", "O", "T". L'ordine in cui vengono disegnate le lettere non ha importanza.

Suggerimento: per semplificare la scrittura delle risposte, potrebbe essere meglio rispondere alla domanda: qual è la probabilità di avere la parola "STIVALE" tra le tue mosse possibili dopo aver estratto 7 lettere da una nuova busta.

(l'introduzione del problema è stata copiata da questa domanda simile )

È richiesta una formula Sfortunatamente, la situazione è così complicata che sembra che qualsiasi formula sarà semplicemente un modo indiretto di elencare tutte le possibilità. Invece, questa risposta offre un algoritmo che è (a) equivalente a una formula che coinvolge somme di prodotti con coefficienti binomiali e (b) può essere portato su molte piattaforme.

---

Per ottenere una formula del genere, suddividere le possibilità in gruppi reciprocamente disgiunti in due modi: in base a quante lettere non presenti nella parola sono selezionate nel rack (lasciare che sia ) e in base a quanti caratteri jolly (spazi) sono selezionati ( lascia che sia w ). Quando ci sono r = 7 tessere nel rack, N tessere disponibili, M tessere disponibili con lettere non nella parola e W = 2 spazi vuoti disponibili, il numero di possibili scelte fornite da ( m , w ) è$m$$w$$r=7$$N$$M$$W=2$$(m,w)$

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

perché le scelte di lettere non vuote, spazi vuoti e lettere di parole sono condizionate indipendentemente da $(m,w,r).$

Questo riduce il problema di trovare il numero di modi per scrivere una parola quando si seleziona solo dalle piastrelle che rappresentano le lettere della parola, dato che grezzi sono disponibili e r - m - w piastrelle saranno selezionati. La situazione è disordinata e nessuna formula chiusa sembra disponibile. Ad esempio, con w = 0 spazi vuoti e m = 3 lettere fuori parola verranno disegnate esattamente quattro lettere per scrivere "boot" che sono state disegnate dalle tessere "b", "o" e "t" . Dato che ci sono 2 "b", 8 "o" e $w$$r-m-w$$w=0$$m=3$$2$$8$$6$"t" è nel set di tessere Scrabble, ci sono probabilità positive di disegno (multiset) "bboo", "bbot", "bbtt", "booo", "boot", "bott", "bttt", "oooo "," ooot "," oott "," ottt "e" tttt ", ma solo uno di questi incantesimi" avvia ". E quello era il caso facile! Ad esempio, supponendo che il rack contenga cinque tessere scelte casualmente dalle tessere "o", "b" e "t", insieme a entrambi gli spazi vuoti, ci sono molti altri modi per scrivere "boot" - e non per compilarlo. Ad esempio, "boot" può essere scritto da "__boott" e "__bbttt", ma non da "__ttttt".

Questo conteggio - il cuore del problema - può essere gestito in modo ricorsivo. Lo descriverò con un esempio. Supponiamo di voler contare i modi di scrivere "boot" con una casella vuota e altre quattro tessere dalla collezione di tessere "b", "o" e "t" (da cui le rimanenti due tessere mostrano lettere non vuote non in { "b", "o", "t"}). Considera la prima lettera, "b":

1. È possibile disegnare una "b" modi tra le due tessere "b" disponibili. Ciò riduce il problema al conteggio del numero di modi per scrivere il suffisso "oot" usando entrambi gli spazi vuoti e solo altre tre tessere dalla raccolta di tessere "o" e "t".$\binom{2}{1}$

2. Un vuoto può essere designato come "b". Ciò riduce il problema al conteggio del numero di modi di scrivere "oot" usando il vuoto rimanente e solo altre tre tessere dalla raccolta di tessere "o" e "t".

In generale, i passaggi (1) e (2) - che sono disgiunti e quindi contribuiscono in modo aggiuntivo ai calcoli della probabilità - possono essere implementati come un ciclo sul possibile numero di spazi che potrebbero essere utilizzati per la prima lettera. Il problema ridotto viene risolto in modo ricorsivo. Il caso base si verifica quando è rimasta una lettera, c'è un certo numero di tessere con quella lettera disponibile e potrebbero esserci anche degli spazi vuoti nel rack. Dobbiamo solo assicurarci che il numero di spazi vuoti nel rack più il numero di tessere disponibili sia sufficiente per ottenere la quantità desiderata di quest'ultima lettera.

Ecco il Rcodice per il passaggio ricorsivo. rackdi solito è uguale a , è una matrice di conteggi delle lettere (come ), è una struttura simile che dà il numero di tessere disponibili con quelle lettere, ed è il numero di spazi bianchi che si presume si verifichino nel rack.$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))
}

Un'interfaccia per questa funzione specifica i riquadri Scrabble standard, converte una determinata parola nella sua struttura di dati multiset ed esegue la doppia somma su e w . Qui è dove i coefficienti binomiali ($m$$w$ e ($\binom{M}{m}$ sono calcolati e moltiplicati.$\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)))
}

---

Proviamo questa soluzione e cronometriamo mentre procediamo. Il seguente test utilizza gli stessi input impiegati nelle simulazioni di @Rasmus Bååth :

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

Questa macchina registra un tempo totale trascorso di secondi: ragionevolmente veloce. I risultati?$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

La probabilità di "boot" di è esattamente uguale al valore 2.381.831 / 333.490.850 ottenuto in mia altra risposta (che utilizza un metodo simile, ma divani in un quadro più potente che richiede una piattaforma di calcolo algebra simbolica). Le probabilità per tutte e quattro le parole sono ragionevolmente vicino alle simulazioni del Baath (che non si poteva pretendere di dare un valore preciso per "zoologia" a causa della sua bassa probabilità di 11840 / 16.007.560 mila ottocento , che è meno di uno su un milione).$114327888/16007560800$$2381831/333490850$$11840/16007560800,$

Le risposte alla domanda di riferimento si applicano direttamente qui: crea un dizionario costituito solo dalla parola target (e dalle sue possibili ortografie con caratteri jolly), calcola la possibilità che un rack casuale non possa formare il target e sottralo da . Questo calcolo è veloce.$1$

Le simulazioni (mostrate alla fine) supportano le risposte calcolate.

---

Dettagli

Come nella risposta precedente, Mathematica viene utilizzata per eseguire i calcoli.

1. Specifica il problema: la parola (o le parole, se lo desideri), le lettere, i loro conteggi e le dimensioni del rack. Poiché tutte le lettere non presenti nella parola agiscono allo stesso modo, accelera notevolmente il calcolo per sostituirle tutte con un singolo simbolo rappresenta "qualsiasi lettera non presente nella parola".$\chi$

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

2. Crea un dizionario di questa parola (o parole) e aumentalo per includere tutti i possibili caratteri ortografici.

   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. Calcola le non parole:

   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$

   (Ci sono non parole in questo caso.)$185$

4. Calcola le possibilità. Per il campionamento con sostituzione, basta sostituire i conteggi delle tessere per le variabili:

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

   $\frac{207263413}{39062500000}$

   Questo valore è circa $0.00756036.$

   Per il campionamento senza sostituzione, utilizzare i poteri fattoriali anziché i poteri:

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

   Questo valore è circa I calcoli erano praticamente istantanei.$0.00714212.$

---

Risultati della simulazione

Risultati di iterazioni con sostituzione:$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$

Confrontalo con il valore calcolato relativo al suo errore standard:

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

$-1.41259$

L'accordo va bene, sostenendo fortemente il risultato calcolato.

Risultati di iterazioni senza sostituzione:$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$

Fai il confronto:

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

$0.331106$

L'accordo in questa simulazione è stato eccellente.

Il tempo totale per la simulazione è stato di secondi.$12$

Quindi questa è una soluzione Monte Carlo , cioè simuleremo di disegnare le tessere un milione di volte e poi calcoleremo quanti di questi disegni simulati ci hanno permesso di formare la parola data. Ho scritto la soluzione in R, ma potresti usare qualsiasi altro linguaggio di programmazione, ad esempio Python o Ruby.

Per prima cosa descriverò come simulare un pareggio. Per prima cosa definiamo le frequenze delle tessere.

# 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

Quindi codifica la parola come vettore di conteggi di lettere.

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 

Ora disegna un campione di sette tessere e codificale nello stesso modo della parola.

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 

Alla fine, calcola quali lettere mancano ...

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 

... e sommare il numero di lettere mancanti e sottrarre il numero di spazi disponibili. Se il risultato è zero o inferiore siamo riusciti a scrivere la parola.

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

In questo caso particolare non abbiamo pensato ... Ora dobbiamo solo ripetere più volte e calcolare la percentuale di pareggi riusciti. Tutto ciò viene eseguito dalla seguente funzione R:

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

Ecco repsil numero di estrazioni simulate. Ora possiamo provarlo con un numero di parole diverse.

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

Per la parola "BOOT" senza caratteri jolly:

$$p_0=\frac{\binom{n_b}{1}\binom{n_o}{2}\binom{n_t}{1}\binom{n-4}{3}}{\binom{n}{7}}$$ Con i caratteri jolly, diventa più noioso. Permettere$p_k$ indica la probabilità di poter giocare a "BOOT" con $k$ jolly: $$\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})!}$