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

Supponi di avere una borsa con $n$ tessere, ognuna con una lettera. Ci sono $n_A$ tessere A con la lettera 'A', con 'B', e così via, e tessere 'jolly' (abbiamo ). Supponiamo di avere un dizionario con un numero finito di parole. Scegli piastrelle dalla borsa senza sostituzione. Come calcoleresti (o stimerai) la probabilità che tu possa formare zero parole dal dizionario date le tessere selezionate?$n_B$$n_*$$n = n_A + n_B + \ldots + n_Z + n_*$$k$$k$

Per coloro che non hanno familiarità con Scrabble (TM), il carattere jolly può essere utilizzato per abbinare qualsiasi lettera. Pertanto, la parola [ BOOT ] potrebbe essere "digitata" con le tessere "B", "*", "O", "T".

Per dare un'idea della portata del problema, $k$ è piccolo, come 7, $n$ è circa 100, e il dizionario contiene circa 100.000 parole di dimensione $k$ o inferiore.

modifica: Per "forma una parola", intendo una parola di lunghezza non maggiore di $k$ . Pertanto, se la parola [ A ] è nel dizionario, quindi disegnando anche una sola "A" dalla borsa, si è "formata una parola". Il problema dei caratteri jolly è radicalmente semplificato se si può presumere che ci siano parole di lunghezza 1 nel dizionario. Se ci sono, qualsiasi estrazione di un carattere jolly può corrispondere automaticamente a una lunghezza di 1 parola, e quindi ci si può concentrare sul caso in cui non ci sono caratteri jolly. Pertanto, la forma più scivolosa del problema non ha parole di 1 lettera nel dizionario.

Inoltre, dovrei dichiarare esplicitamente che l'ordine in cui le lettere sono tratte dalla borsa è irrilevante. Non è necessario disegnare le lettere nell'ordine "corretto" della parola.

Questo è un (lungo!) Commento sul bel lavoro che @vqv ha pubblicato in questa discussione. Ha lo scopo di ottenere una risposta definitiva. Ha fatto il duro lavoro di semplificare il dizionario. Non resta che sfruttarlo al massimo. I suoi risultati suggeriscono che una soluzione a forza bruta è fattibile . Dopotutto, incluso un carattere jolly, ci sono al massimo parole che si possono fare con 7 caratteri, e ne sembrano meno di 1/10000 - diciamo, circa un milione - non riesco a includere alcune parole valide. $27^7 = 10,460,353,203$

Il primo passo è aumentare il dizionario minimo con un carattere jolly "?". 22 delle lettere compaiono in parole di due lettere (tutte tranne c, q, v, z). Aggiungete un jolly a quelle 22 lettere e aggiungetele al dizionario: {a ?, b ?, d ?, ..., y?} Sono ora presenti. Allo stesso modo possiamo ispezionare le parole minime di tre lettere, causando alcune parole aggiuntive apparire nel dizionario. Infine, aggiungiamo "??" al dizionario. Dopo aver rimosso le ripetizioni che ne risultano, contiene 342 parole minime.

Un modo elegante di procedere - uno che utilizza davvero una piccolissima quantità di codifica - è vedere questo problema come algebrico . Una parola, considerata come un insieme di lettere non ordinate, è solo un monomio. Ad esempio, "spats" è il monomiale . Il dizionario è quindi una raccolta di monomi. Sembra$a p s^2 t$

$$\{a^2, a b, a d, ..., o z \psi, w x \psi, \psi^2\}$$

(dove, per evitare confusione, ho scritto per il carattere jolly).$\psi$

Un rack contiene una parola valida se e solo se quella parola divide il rack.

Un modo più astratto, ma estremamente potente, per dirlo è che il dizionario genera un ideale nell'anello polinomiale R = Z [ a , b , … , z , ψ ] e che i rack con parole valide diventano zero nel quoziente ring R / I , mentre i rack senza parole valide rimangono diversi da zero nel quoziente. Se formiamo la somma di tutti i rack in R e la calcoliamo in questo anello di quoziente, allora il numero di rack senza parole è uguale al numero di monomi distinti nel quoziente.$I$$R = \mathbb{Z}[a, b, \ldots, z, \psi]$$R/I$$R$

Inoltre, la somma di tutti i rack in è semplice da esprimere. Sia α = a + b + ⋯ + z + ψ la somma di tutte le lettere dell'alfabeto. α 7 contiene un monomio per ciascun rack. (Come bonus aggiuntivo, i suoi coefficienti contano il numero di modi in cui ogni rack può essere formato, permettendoci di calcolare la sua probabilità se vogliamo.)$R$$\alpha = a + b + \cdots + z + \psi$$\alpha^7$

Come semplice esempio (per vedere come funziona), supponiamo che (a) non usiamo i caratteri jolly e (b) tutte le lettere da "a" a "x" siano considerate parole. Quindi le uniche possibili cremagliere dalle quali non è possibile formare le parole devono consistere interamente in y e z. Calcoliamo modulo l'ideale generato da { a , b , c , ... , x } un passo alla volta, quindi:$\alpha=(a+b+c+\cdots+x+y+z)^7$$\{a,b,c, \ldots, x\}$

$$\eqalign{ \alpha^0 &= 1 \cr \alpha^1 &= a+b+c+\cdots+x+y+z \equiv y+z \mod I \cr \alpha^2 &\equiv (y+z)(a+b+\cdots+y+z) \equiv (y+z)^2 \mod I \cr \cdots &\cr \alpha^7 &\equiv (y+z)^6(a+b+\cdots+y+z) \equiv (y+z)^7 \mod I \text{.} }$$

Possiamo leggere la possibilità di ottenere un rack senza parole dalla risposta finale, : ciascun coefficiente conta i modi in cui è possibile disegnare il rack corrispondente. Ad esempio, ci sono 21 (su 26 ^ 7 possibili) modi per disegnare 2 y e 5 z perché il coefficiente di $y^7 + 7 y^6 z + 21 y^5 z^2 + 35 y^4 z^3 + 35 y^3 z^4 + 21 y^2 z^5 + 7 y z^6 + z^7$ uguale a 21.$y^2 z^5$

Dai calcoli elementari, è ovvio che questa è la risposta corretta. Il punto è che questa procedura funziona indipendentemente dal contenuto del dizionario.

Nota come ridurre la potenza del modulo l'ideale in ogni fase riduce il calcolo: questa è la scorciatoia rivelata da questo approccio. (Fine dell'esempio.)

I sistemi di algebra polinomiale implementano questi calcoli . Ad esempio, ecco il codice Mathematica :

alphabet =  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 + \[Psi];
dictionary = {a^2, a b, a d, a e, ..., w z \[Psi], \[Psi]^2};
next[pp_] := PolynomialMod[pp alphabet, dictionary];
nonwords = Nest[next, 1, 7];
Length[nonwords]

(Il dizionario può essere costruito in modo semplice dal min. Min di @ vqv; ho inserito qui una riga che mostra che è abbastanza corto da essere specificato direttamente se lo desideri.)

L'output - che richiede dieci minuti di calcolo - è 577958. ( NB In una versione precedente di questo messaggio avevo fatto un piccolo errore nella preparazione del dizionario e ottenuto 577940. Ho modificato il testo per riflettere ciò che spero siano ora i risultati corretti!) Poco meno del milione o così mi aspettavo, ma dello stesso ordine di grandezza.

Per calcolare la possibilità di ottenere un tale rack, dobbiamo tenere conto del numero di modi in cui il rack può essere disegnato. Come abbiamo visto nell'esempio, questo equivale al suo coefficiente in . La possibilità di disegnare alcuni di questi rack è la somma di tutti questi coefficienti, facilmente reperibile impostando tutte le lettere uguali a 1:$\alpha^7$

nonwords /. (# -> 1) & /@ (List @@ alphabet)

La risposta equivale a 1066056120, dando una probabilità del 10,1914% di estrarre un rack da cui non è possibile formare una parola valida (se tutte le lettere sono ugualmente probabili).

Quando le probabilità delle lettere variano, basta sostituire ogni lettera con la possibilità di essere disegnata:

tiles = {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, 2};
chances = tiles / (Plus @@ tiles);
nonwords /. (Transpose[{List @@ alphabet, chances}] /. {a_, b_} -> a -> b)

L'output è 1,079877553303%, la risposta esatta (anche se usando un modello approssimativo, disegnando con la sostituzione). Guardando indietro, ci sono volute quattro righe per inserire i dati (alfabeto, dizionario e frequenze alfabetiche) e solo tre righe per eseguire il lavoro: descrivere come prendere la potenza successiva di modulo I , prendere la 7a potenza in modo ricorsivo e sostituire la probabilità per le lettere.$\alpha$$I$

È molto difficile disegnare un rack che non contenga alcuna parola valida in Scrabble e nelle sue varianti. Di seguito è riportato un programma R che ho scritto per stimare la probabilità che il rack a 7 tessere iniziale non contenga una parola valida. Utilizza un approccio monte carlo e il lessico Words With Friends (non sono riuscito a trovare il lessico ufficiale di Scrabble in un formato semplice). Ogni prova consiste nel disegnare un rack di 7 tessere e quindi verificare se il rack contiene una parola valida.

Parole minime

Non è necessario eseguire la scansione dell'intero lessico per verificare se il rack contiene una parola valida. Hai solo bisogno di scansionare un lessico minimo composto da parole minime . Una parola è minima se non contiene altre parole come sottoinsieme. Ad esempio 'em' è una parola minima; 'vuoto' non lo è. Il punto è che se un rack contiene la parola x , deve contenere anche qualsiasi sottoinsieme di x . In altre parole: un rack non contiene parole se non contiene parole minime. Fortunatamente, la maggior parte delle parole nel lessico non sono minime, quindi possono essere eliminate. Puoi anche unire parole equivalenti di permutazione. Sono stato in grado di ridurre il lessico di Words With Friends da 172.820 a 201 parole minime.

I caratteri jolly possono essere facilmente gestiti trattando rack e parole come distribuzioni sulle lettere. Controlliamo se un rack contiene una parola sottraendo una distribuzione dall'altra. Questo ci dà il numero di ogni lettera mancante dal rack. Se la somma di quel numero è il numero di caratteri jolly, la parola è nel rack.$\leq$

L'unico problema con l'approccio Monte Carlo è che l'evento a cui siamo interessati è molto raro. Quindi dovrebbero essere necessarie molte, molte prove per ottenere una stima con un errore standard abbastanza piccolo. Ho fatto funzionare il mio programma (incollato in basso) con prove e ottenuto una probabilità stimata di 0,004 che la cremagliera iniziale non contiene una parola valida . L'errore standard stimato di tale stima è 0.0002. Il mio Mac Pro ha impiegato solo un paio di minuti, incluso il download del lessico.$N=100,000$

Sarei interessato a vedere se qualcuno può inventare un algoritmo esatto efficiente. Un approccio ingenuo basato sull'inclusione-esclusione sembra che potrebbe comportare un'esplosione combinatoria.

Inclusione-esclusione

Penso che questa sia una cattiva soluzione, ma qui c'è comunque uno schizzo incompleto. In linea di principio è possibile scrivere un programma per eseguire il calcolo, ma le specifiche sarebbero tortuose.

La probabilità che desideriamo calcolare è L'evento all'interno della probabilità sul lato destro è un'unione di eventi: P ( k -tile rack contiene una parola ) = P ( ∪ x ∈ M { k -tile rack contiene  x } ) , dove

$$P(k\text{-tile rack does not contain a word}) = 1 - P(k\text{-tile rack contains a word}) .$$ $$P(k\text{-tile rack contains a word}) = P\left(\cup_{x \in M} \{ k\text{-tile rack contains }x \} \right),$$ $M$è un lessico minimo. Possiamo espanderlo utilizzando la formula di inclusione-esclusione. Si tratta di considerare tutte le possibili intersezioni degli eventi sopra. Let denota l'insieme potenza di M , ossia l'insieme di tutti i possibili sottoinsiemi di M . Poi $\mathcal{P}(M)$$M$$M$ $$\begin{align} &P(k\text{-tile rack contains a word}) \\ &= P\left(\cup_{x \in M} \{ k\text{-tile rack contains }x \} \right) \\ &= \sum_{j=1}^{|M|} (-1)^{j-1} \sum_{S \in \mathcal{P}(M) : |S| = j} P\left( \cap_{x \in S} \{ k\text{-tile rack contains }x \} \right) \end{align}$$

$$\cap_{x \in S} \{ k\text{-tile rack contains }x \}$$ $S$

Poi

$$\begin{align} &P\left( \cap_{x \in S} \{ k\text{-tile rack contains }x \} \right) \\ &= \sum_{w=0}^{n_{*}} P\left( \cap_{x \in S} \{ k\text{-tile rack contains }x \} | k\text{-tile rack contains } w \text{ wildcards} \right) \\ &\quad \times P(k\text{-tile rack contains } w \text{ wildcards}) . \end{align}$$

$2^{|M|}$$2^{|M|} \approx 3.2 \times 10^{60}$

Scansione di tutti i possibili rack

$k$-tile rack fino a quando non si ottiene l'insieme di rack che non contiene parole. Per Scrabble (o Words With Friends) il numero di possibili rack da 7 tessere è in decine di miliardi. Contare il numero di quelli che non contengono una possibile parola dovrebbe essere fattibile con poche decine di righe di codice R. Ma penso che dovresti essere in grado di fare meglio del semplice elenco di tutti i possibili rack. Ad esempio, "aa" è una parola minima. Ciò elimina immediatamente tutti i rack contenenti più di una "a". Puoi ripetere con altre parole. La memoria non dovrebbe essere un problema per i computer moderni. Un rack Scrabble a 7 tessere richiede meno di 7 byte di memoria. Nel peggiore dei casi useremmo alcuni gigabyte per memorizzare tutti i possibili rack, ma non penso neanche che sia una buona idea. Qualcuno potrebbe voler pensare di più a questo.

Programma Monte Carlo R.

# 
#  scrabble.R
#  
#  Created by Vincent Vu on 2011-01-07.
#  Copyright 2011 Vincent Vu. All rights reserved.
# 

# The Words With Friends lexicon
# http://code.google.com/p/dotnetperls-controls/downloads/detail?name=enable1.txt&can=2&q=
url <- 'http://dotnetperls-controls.googlecode.com/files/enable1.txt'
lexicon <- scan(url, what=character())

# Words With Friends
letters <- c(unlist(strsplit('abcdefghijklmnopqrstuvwxyz', NULL)), '?')
tiles <- c(9, 2, 2, 5, 13, 2, 3, 4, 8, 1, 1, 4, 2, 5, 8, 2, 1, 6, 5, 7, 4, 
           2, 2, 1, 2, 1, 2)
names(tiles) <- letters

# Scrabble
# tiles <- c(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, 2)


# Reduce to permutation equivalent words
sort.letters.in.words <- function(x) {
  sapply(lapply(strsplit(x, NULL), sort), paste, collapse='')
}

min.dict <- unique(sort.letters.in.words(lexicon))
min.dict.length <- nchar(min.dict)

# Find all minimal words of length k by elimination
# This is held constant across iterations:
#   All words in min.dict contain no other words of length k or smaller
k <- 1
while(k < max(min.dict.length))
{
  # List all k-letter words in min.dict
  k.letter.words <- min.dict[min.dict.length == k]

  # Find words in min.dict of length > k that contain a k-letter word
  for(w in k.letter.words)
  {
    # Create a regexp pattern
    makepattern <- function(x) {
      paste('.*', paste(unlist(strsplit(x, NULL)), '.*', sep='', collapse=''), 
            sep='')
    }
    p <- paste('.*', 
               paste(unlist(strsplit(w, NULL)), 
                     '.*', sep='', collapse=''), 
               sep='')

    # Eliminate words of length > k that are not minimal
    eliminate <- grepl(p, min.dict) & min.dict.length > k
    min.dict <- min.dict[!eliminate]
    min.dict.length <- min.dict.length[!eliminate]
  }
  k <- k + 1
}

# Converts a word into a letter distribution
letter.dist <- function(w, l=letters) {
  d <- lapply(strsplit(w, NULL), factor, levels=l)
  names(d) <- w
  d <- lapply(d, table)
  return(d)
}

# Sample N racks of k tiles
N <- 1e5
k <- 7
rack <- replicate(N,
                  paste(sample(names(tiles), size=k, prob=tiles), 
                        collapse=''))

contains.word <- function(rack.dist, lex.dist)
{
  # For each word in the lexicon, subtract the rack distribution from the 
  # letter distribution of the word.  Positive results correspond to the 
  # number of each letter that the rack is missing.
  y <- sweep(lex.dist, 1, rack.dist)

  # If the total number of missing letters is smaller than the number of 
  # wildcards in the rack, then the rack contains that word
  any(colSums(pmax(y,0)) <= rack.dist[names(rack.dist) == '?'])
}

# Convert rack and min.dict into letter distributions
min.dict.dist <- letter.dist(min.dict)
min.dict.dist <- do.call(cbind, min.dict.dist)
rack.dist <- letter.dist(rack, l=letters)

# Determine if each rack contains a valid word
x <- sapply(rack.dist, contains.word, lex.dist=min.dict.dist)

message("Estimate (and SE) of probability of no words based on ", 
        N, " trials:")
message(signif(1-mean(x)), " (", signif(sd(x) / sqrt(N)), ")")

$1$$k$

La seconda ragione è che MC è davvero fattibile: devi solo farlo bene. Il paragrafo precedente fornisce un indizio: non solo generare parole a caso e cercarle; invece, analizza prima il dizionario e sfrutta la sua struttura.

$k!-1$

$k$quindi cerca questa "parola" ordinata in un albero costruito dai rappresentanti ordinati delle parole nel dizionario originale. Questo sarà in realtà più piccolo dell'albero originale perché unisce tutti i set di parole che sono equivalenti all'ordinamento, come {stop, post, pot, opts, spot}. In effetti, in un dizionario inglese questa classe di parole non sarebbe mai stata raggiunta comunque perché "così" sarebbe stato trovato per primo. Vediamo questo in azione. Il multiset ordinato è "opst"; la "o" si diramerebbe a tutte le parole che contengono solo le lettere {o, p, ..., z}, la "p" si diramerebbe a tutte le parole che contengono solo {o, p, ..., z} e al massimo una "o", e infine la "s" si ramificherebbe alla foglia "così"! (Ho ipotizzato che nessuno dei plausibili candidati "o", "op", "

È necessaria una modifica per gestire i caratteri jolly: lascerò che i tipi di programmatore tra di voi ci pensino. Non aumenterà la dimensione del dizionario (dovrebbe ridurlo, in effetti); rallenterà leggermente l'attraversamento dell'albero, ma senza modificarlo in alcun modo fondamentale. In qualsiasi dizionario che contiene una parola di una sola lettera, come l'inglese ("a", "i"), non vi è alcuna complicazione: la presenza di un carattere jolly significa che puoi formare una parola! (Questo suggerisce che la domanda originale potrebbe non essere così interessante come sembra.)

Il risultato è che una singola ricerca nel dizionario richiede (a) l'ordinamento a $k$-letter multiset e (b) attraversando non più di $k$bordi di un albero. Il tempo di esecuzione è$O(k \log(k))$. Se si generano abilmente multiset casuali in ordine ordinato (posso pensare a diversi modi efficienti per farlo), il tempo di esecuzione si riduce a$O(k)$. Moltiplicare questo per il numero di iterazioni per ottenere il tempo di esecuzione totale.

Scommetto che potresti condurre questo studio con un vero set di Scrabble e un milione di iterazioni in pochi secondi.

Approccio Monte Carlo

L'approccio rapido e sporco è quello di fare uno studio di Monte Carlo. Disegnare$k$ piastrelle $m$ volte e per ogni sorteggio di $k$ tiles see if you can form a word. Denote the number of times you could form a word by $m_w$. The desired probability would be:

$$1 - \frac{m_w}{m}$$

Direct Approach

Let the number of words in the dictionary be given by $S$. Let $t_s$ be the number of ways in which we can form the $s^\mbox{th}$ word. Let the number of letters needed by the $s^\mbox{th}$ word be denoted by ${m_a, m_b, ..., m_z}$ (i.e., the $s^\mbox{th}$ word needs $m_a$ number of 'a' letters etc). Denote the number of words we can form with all tiles by $N$.

$$N = \binom{n}{k}$$

and

$$t_s = \binom{n_a}{m_a} \binom{n_b}{m_b} ... \binom{n_z}{m_z}$$

(Including the impact of wildcard tiles is a bit trickier. I will defer that issue for now.)

Thus, the desired probability is:

$$1 - \frac{\sum_s{t_s}}{N}$$