Scrabble'da bir harf kutusundan bir kelime çizememe olasılığı

Her birinin üzerinde bir harf bulunan taşlı bir çantanız olduğunu varsayalım . Orada 'A' harfi ile fayans 'B' ile, vb, ve 'joker' karolar (Elimizdeki ). Sonlu sözcüklerden oluşan bir sözlüğünüz olduğunu varsayalım. Torbadan değiştirmeden karoları seçersiniz . Seçilen döşemeleri verilen sözlükten sıfır sözcük oluşturma olasılığını nasıl hesaplarsınız (veya tahmin edersiniz) ?n A n B n * n = n A + n B + ... + n Z + n * k $n$$n_A$$n_B$$n_*$$n = n_A + n_B + \ldots + n_Z + n_*$$k$$k$

Scrabble ™ ile aşina olmayanlar için, joker karakter herhangi bir harfle eşleştirmek için kullanılabilir. Böylece [ BOOT ] kelimesi 'B', '*', 'O', 'T' çinileri ile 'hecelenebilir'.

Sorunun ölçeği hakkında biraz fikir vermek için, 7 gibi küçük, 100 civarındadır ve sözlük veya daha küçük boyutlu 100,000 kelime içermektedir .n $k$$n$$k$

düzenleme: 'bir kelime' ile, daha büyük olmayan bir kelimeyi kastediyorum . Bu nedenle, [ A ] kelimesi sözlükte ise, o zaman torbadan tek bir 'A' bile çizildiğinde, biri 'bir kelime' oluşturmuştur. Joker karakter problemi, eğer sözlükte 1 uzunluğa sahip kelimeler varsayalımsa radikal bir şekilde basitleşir. Çünkü varsa, herhangi bir joker karakter otomatik olarak 1 kelimelik bir uzunluğa eşleşebilir ve böylece joker karakterlerin bulunmadığı duruma konsantre olabilir. Böylece problemin daha kaygan formu sözlükte 1 harfli kelimeler yoktur.$k$

Ayrıca, harflerin torbadan çıkarılma sırasının önemsiz olduğunu açıkça belirtmeliyim. Birinin harfleri kelimenin 'doğru' sırasına göre çizmek zorunda değilsiniz.

Bu, @vqv'nin bu konuya gönderdiği güzel çalışma hakkında (uzun!) Bir yorum. Kesin bir cevap elde etmeyi amaçlar. Sözlüğü basitleştirmek için sıkı bir çalışma yaptı. Geriye kalan tek şey onu sonuna kadar kullanmak. Elde ettiği sonuçlar kaba kuvvetli bir çözümün mümkün olduğunu gösteriyor . Sonuçta, bir joker karakter dahil, en fazla kelimeden biri 7 karakterden oluşabiliyor ve bunların 1 / 10000'den daha azına benziyor - bir milyon civarında - olacak geçerli bir kelime içermemekte. $27^7 = 10,460,353,203$

İlk adım, minimal sözlüğü "?" Joker karakteriyle genişletmektir. Harflerin 22'si iki harften oluşur (hepsi c, q, v, z hariç). Bu 22 harfe joker karakter ekleyin ve bunları şu sözlüğe ekleyin: {a ?, b ?, d ?, ..., y?} Şimdi içeride. Benzer şekilde, en az üç harften oluşan kelimeleri inceleyebiliriz, ek kelimelere neden olabiliriz. sözlükte görünmek için Sonunda "??" ekleriz. Sözlüğe Ortaya çıkan tekrarları sildikten sonra en az 342 kelime içerir.

Gerçekten de çok küçük bir kodlama kullanan, devam etmenin zarif bir yolu, bu sorunu cebirsel olarak görmektir . Sırasız bir harf kümesi olarak kabul edilen bir kelime, sadece bir monomialdir. Örneğin, "Spats" monomial olan . Bu nedenle sözlük, bir monom koleksiyonudur. Benziyor$a p s^2 t$

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

(karışıklıktan kaçınmak için, joker karakter için yazdım ).$\psi$

Bir raf, yalnızca bu kelime rafa bölündüğünde geçerli bir kelime içerir.

Daha soyut, ama son derece güçlü, bunu söylemenin bir yolu, sözlüğün R = Z [ a , b , … , z , om ] polinomu halkasında ideal bir üretmesi ve geçerli kelimelere sahip rafların bölüm içinde sıfıra dönmesidir. halka R / I , oysa geçerli sözcük içermeyen raflar bölüm içinde sıfır kalmaz. Eğer R'deki tüm rafların toplamını oluşturur ve bu bölüm halkasında hesaplarsak, sözsüz raf sayısı, bölümdeki farklı monomiallerin sayısına eşittir.$I$$R = \mathbb{Z}[a, b, \ldots, z, \psi]$$R/I$$R$

Ayrıca, tüm rafların toplamının ifade edilmesi kolaydır. Let α = bir + b + ⋯ + z + ψ alfabenin tüm harfleri toplamı olacaktır. α 7 her bir raf için, bir tek terimli içerir. (Ek bir avantaj olarak, katsayıları, her bir rafın oluşturulabileceği sayıları sayar ve eğer istersen olasılığını hesaplamamızı sağlar.)$R$$\alpha = a + b + \cdots + z + \psi$$\alpha^7$

Basit bir örnek olarak (bunun nasıl çalıştığını görmek için), (a) joker karakter kullanmıyoruz ve (b) "a" dan "x" e kadar olan tüm harfleri kelimeler olarak kabul ediyoruz. Öyleyse, sözcüklerin oluşamayacağı olası raflar tamamen y ve z 'den oluşmalıdır. Bu işlem tarafından oluşturulan ideal bir modulo { a , b , c , ... , x } böylece her seferinde bir adım:$\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{.} }$$

Son cevaptan kelime olmayan bir raf alma şansını okuyabiliriz, : her katsayı, ilgili rafın nasıl çekilebileceğini sayar. Örneğin, 2 (5 ve 26) mümkün) 2 y ve 5 z'yi çizmenin bir yolu vardır, çünkü y katsayısı$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$ 21 eşittir.$y^2 z^5$

Temel hesaplamalardan, bunun doğru cevap olduğu açıktır. Bütün mesele şu ki, bu prosedür sözlüğün içeriğinden bağımsız olarak çalışır.

Güç modülünün her aşamada ideal olarak azaltılmasının hesaplamayı nasıl azalttığına dikkat edin: bu, bu yaklaşımın ortaya çıkardığı kısayol. (Örneğin sonu.)

Polinom cebir sistemleri bu hesaplamaları uygular . Örneğin, işte Mathematica kodu:

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]

(Sözlük @ vqv'nin min.dict'sinden basit bir şekilde oluşturulabilir; İsterseniz doğrudan belirtilmesinin yeterince kısa olduğunu gösteren bir çizgi koyuyorum.)

Hesaplama on dakika süren çıktı 577958 'dir. ( NB Bu mesajın önceki sürümlerinde sözlüğü hazırlarken ufak bir hata yaptım ve 577940' ı elde ettim. doğru sonuçlar!) Beklediğim milyondan biraz daha az, ama aynı büyüklükte.

Böyle bir raf alma şansını hesaplamak için , rafın nasıl çekilebileceğini hesaplamamız gerekir. Örnekte gördüğümüz gibi, bu katsayısına eşittir . Çizim şansı bazı tür raf 1'e eşit kolaylıkla tüm harfleri ayarlayarak bulunan tüm bu katsayılar, toplamıdır:$\alpha^7$

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

Cevap, 1066056120’ye eşittir,% 10.1914 oranında geçerli bir kelime oluşturulamayan bir raf çekme şansı verir (eğer tüm harfler eşit derecede muhtemel ise).

Harflerin olasılıkları değiştiğinde, sadece her bir harfi çizilme şansıyla değiştirin:

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)

Çıktı % 1.079877553303'tür, kesin cevap (yaklaşık bir model kullanılsa da, değiştirilmesi ile çizim ). Geriye dönüp bakıldığında, verileri girmek için dört satır gerekiyordu (alfabe, sözlük ve alfabe frekansları) ve işi yapmak için sadece üç satır vardı: modulo I'in bir sonraki gücünün nasıl alınacağını, 7. gücün tekrarlı bir şekilde nasıl alınacağını ve ikame edicinin yerine geçeceğini tanımlayın . harfler için olasılıklar.$\alpha$$I$

Scrabble ve değişkenlerinde geçerli bir kelime içermeyen bir raf çizmek çok zordur. Aşağıda, ilk 7 kiremit rafının geçerli bir kelime içermemesi ihtimalini tahmin etmek için yazdığım bir R programı verilmiştir. Monte bir carlo yaklaşımı ve Arkadaşlarla Sözler sözlüğünü kullanır (Resmi Scrabble sözlüğünü kolay bir biçimde bulamadım). Her deneme, 7 döşemeli bir raf çizmekten ve rafın geçerli bir kelime içerip içermediğini kontrol etmekten oluşur.

Minimal kelimeler

Rafın geçerli bir kelime içerip içermediğini kontrol etmek için sözlüğün tamamını taramanıza gerek yoktur. Sadece minimum kelimelerden oluşan minimal bir sözlüğü taramanız yeterli . Bir kelime, alt küme olarak başka bir kelime içermiyorsa, minimum düzeydedir. Örneğin 'em' asgari bir kelimedir; 'boş' değil. Bunun amacı, eğer bir raf x kelimesini içeriyorsa, o da herhangi bir x alt kümesini de içermesi gerektiğidir . Başka bir deyişle: Bir raf, hiç bir kelime içermiyorsa, minimum kelime içermiyorsa. Neyse ki, sözlükteki sözcüklerin çoğu minimal değil, bu yüzden yok edilebilirler. Permütasyon eşdeğeri kelimeleri de birleştirebilirsiniz. Arkadaşça Sözcükler sözlüğünü 172,820'den 201 en az kelimeye indirmeyi başardım.

Joker karakterler, raflara ve kelimelere harflerin üzerine dağıtılmış olarak bakılarak kolayca kullanılabilir. Bir rafın bir dağıtım diğerinden çıkarılarak bir kelime içerip içermediğini kontrol ederiz. Bu bize rafta eksik olan her bir mektubun numarasını verir. Bu sayının toplamı joker karakterlerin sayısı ise, kelime rafta demektir.$\leq$

Monte edilmiş carlo yaklaşımındaki tek sorun, ilgilendiğimiz olayın çok nadir olması. Bu nedenle, yeterince küçük bir standart hatayla bir tahminde bulunmak için birçok denemenin yapılması gerekir. Programımı (altta yapıştırılmış) denemeyle çalıştırdım ve ilk rafın geçerli bir kelime içermemesi ihtimalinin 0.004 olabileceğini tahmin ettim . Bu tahminin tahmini standart hatası 0,0002'dir. Mac Pro'mda yayın yapmak sadece birkaç dakika sürdü, sözlüğü indirme de dahil.$N=100,000$

Etkili bir algoritma ile birisinin ortaya çıkıp çıkamayacağını görmek isterim. Dahil etme-hariç tutma temelli naif bir yaklaşım, bir birleşimsel patlamayı içerebileceği görülüyor.

Dahil etme hariç tutma

Bunun kötü bir çözüm olduğunu düşünüyorum, ama yine de eksik bir taslak. Prensip olarak, hesaplama yapmak için bir program yazabilirsiniz, ancak şartname titiz olacaktır.

Hesaplamak istediğimiz olasılık Sağ taraftaki olasılık içindeki olay bir olaylar birliğidir: P (

$$P(k\text{-tile rack does not contain a word}) = 1 - P(k\text{-tile rack contains a word}) .$$ burada $$P(k\text{-tile rack contains a word}) = P\left(\cup_{x \in M} \{ k\text{-tile rack contains }x \} \right),$$ $M$asgari bir sözlük. Dahil etme-hariç tutma formülünü kullanarak genişletebiliriz. Yukarıdaki olayların olası tüm kesişimlerini dikkate almayı içerir. Let güç kümesini göstermek M , olası tüm alt kümelerinin yani kümesi M . Sonra $\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}$$

Belirlenecek son şey, yukarıdaki son satırdaki olasılığı nasıl hesaplayacağınızdır. Çok değişkenli bir hipergeometri içerir.
raf her kelimeyi içeren bir olaydır S . Bu, joker karakterler nedeniyle başa çıkmak için bir acıdır. Aşağıdaki durumların her birini koşullandırarak göz önünde bulundurmamız gerekir: raf joker karakter içermez, raf 1 joker karakter içerir, raf 2 joker karakter içerir ...

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

Sonra

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

Burada duracağım, çünkü açılımlar tamamen aydınlanmaya değil, yazmaya zorlanıyor. Bunu yapmak için bir bilgisayar programı yazmak daha kolaydır. Ancak şimdiye kadar dahil etme-hariç tutma yaklaşımının anlaşılmaz olduğunu görmelisiniz. 2 içerir | M |$2^{|M|}$Her biri de çok karmaşık olan terimler. Yukarıda düşündüğüm sözlüğü için .$2^{|M|} \approx 3.2 \times 10^{60}$

Tüm olası rafları tarıyor

Bunun hesaplama açısından daha kolay olduğunu düşünüyorum çünkü minimal kelimelerin altkümelerinden daha az olası raf var. Biz gittikçe mümkün kümesi azaltmak $k$- Hiç kelime içermeyen raflar kümesini alana kadar rafları döşeyin. Scrabble için (veya Arkadaşlarla Kelimeler) olası 7 kiremitli rafların sayısı milyarlarca. Olası bir kelime içermeyenlerin sayısının sayılması, birkaç düzine R kodu ile yapılabilir. Ancak bence, tüm olası rafları numaralandırmaktan daha iyisini yapabilmelisiniz. Örneğin, 'aa' asgari bir kelimedir. Bu, birden fazla 'a' içeren tüm rafları derhal ortadan kaldırır. Diğer kelimelerle tekrarlayabilirsiniz. Bellek, modern bilgisayarlar için bir sorun olmamalıdır. 7 döşemeli bir Scrabble rafı, 7 bayttan daha az depolama alanı gerektirir. En kötüsü, tüm olası rafları saklamak için birkaç gigabayt kullanırdık, ama bunun da iyi bir fikir olduğunu sanmıyorum. Birileri bu konuda daha fazla düşünmek isteyebilir.

Monte Carlo R programı

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

İkinci sebep, MC'nin gerçekten uygulanabilir olduğudur: Sadece doğru şekilde yapmalısınız. Yukarıdaki paragraf bir ipucu sağlar: sadece rastgele kelimeler üretmek değil, onları aramak; bunun yerine, önce sözlüğü analiz et ve yapısından faydalan.

$k!-1$

Başka bir deyişle, bir multiset olup olmadığını belirlemek için $k$daha sonra bu sıralanan "kelimeyi", orijinal sözlükteki kelimelerin sıralı temsilcilerinden oluşturulmuş bir ağaçta arayın. Bu aslında orijinal ağaçtan daha küçük olacaktır, çünkü {stop, post, tencere, opts, spot} gibi sıralama kelimesine eşdeğer tüm sözcük gruplarını birleştirir. Aslında, bir İngilizce sözlükte, bu kelimelere hiçbir zaman ulaşılmazdı, çünkü “so” ilk önce bulunacaktı. Bunu eylemde görelim. Sıralanan çoklu ayar "opst"; "o" sadece {o, p, ..., z} harflerini içeren tüm kelimelere dallanır, "p" sadece {o, p, ..., z} harflerini içeren en fazla kelimeye dallanır ve en fazla bir "o" ve nihayet "s" "so" yaprağına dallanacak! (Mantıklı adayların hiçbirinin "o", "op", "olmadığını varsaydım.

Joker karakterlerle başa çıkmak için bir değişiklik yapılması gerekiyor: Aralarındaki programcı türlerinin bunu düşünmesine izin vereceğim. Sözlük boyutunu artırmaz (gerçekte küçültmesi gerekir); ağaç geçişini hafifçe yavaşlatır, ancak herhangi bir temel şekilde değiştirmeden. İngilizce ("a", "i") gibi tek harfli bir kelime içeren herhangi bir sözlükte, hiçbir komplikasyon yoktur: bir joker karakterin varlığı, bir kelime oluşturabileceğiniz anlamına gelir! (Bu, orijinal sorunun göründüğü kadar ilginç olamayacağına işaret eder.)

$k$$k$$O(k \log(k))$$O(k)$ . Toplam çalışma süresini elde etmek için bunu yineleme sayısı ile çarpın.

Bahse girerim bu çalışmayı gerçek bir Scrabble seti ve birkaç saniyede bir milyon yineleme ile yapabilirsin.

Monte Carlo Yaklaşımı

$k$$m$$k$$m_w$

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

Doğrudan yaklaşım

$S$$t_s$$s^\mbox{th}$$s^\mbox{th}$${m_a, m_b, ..., m_z}$$s^\mbox{th}$$m_a$$N$

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

ve

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

(Joker işaretlerin etkisinin dahil edilmesi biraz daha zor. Bu konuyu şimdilik erteleyeceğim.)

Böylece istenen olasılık:

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