글자 맞추기에서 한 글자의 백에서 단어를 그릴 수없는 확률

타일 이있는 가방이 있고 각각에 글자 가있는 것으로 가정 해 봅시다 . 문자 'A' 가있는 타일, 'B'가있는 등, '와일드 카드'타일이 있습니다 ( n = n_A + n_B + \ ldots + n_Z + n_ *가 있습니다 ). 한정된 수의 단어가있는 사전이 있다고 가정합니다. 당신은 선택 K 교체없이 가방에서 타일을. 선택한 k 타일이 주어진 경우 사전에서 0 단어를 형성 할 확률을 어떻게 계산 (또는 추정) 하시겠습니까?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 (TM)에 익숙하지 않은 사용자는 와일드 카드 문자를 사용하여 모든 문자를 일치시킬 수 있습니다. 따라서 [ BOOT ] 라는 단어 는 타일 'B', '*', 'O', 'T'로 '맞춤법'이 될 수 있습니다.

문제의 규모를 이해하기 위해 $k$ 는 7과 같이 작고 , $n$ 은 약 100이며, 사전에는 $k$ 이하 의 약 100,000 단어가 포함되어 있습니다 .

편집 : '단어'를 형성한다는 것은 길이가 k 이하인 단어를 의미합니다 $k$. 따라서 단어 [ A ]가 사전에 있다면, 가방에서 하나의 'A'조차도 그려서 '단어'를 형성 한 것입니다. 사전에 길이가 1 인 단어가 있다고 가정하면 와일드 카드 문제는 근본적으로 단순화됩니다. 존재하는 경우, 임의의 와일드 카드 드로우는 자동으로 길이 1 단어와 일치 할 수 있으므로 와일드 카드가없는 경우에 집중할 수 있습니다. 따라서 더 미끄러운 형태의 문제는 사전에 1 글자 단어가 없습니다.

또한 가방에서 글자가 나오는 순서는 중요하지 않다고 명시 적으로 언급해야합니다. 단어의 '정확한'순서로 글자를 그릴 필요는 없습니다.

이것은 @vqv가이 글에 올린 멋진 작품에 대한 (긴!) 주석입니다. 명확한 답을 얻는 것을 목표로합니다. 그는 사전을 단순화하기 위해 열심히 노력했습니다. 남아있는 것은 그것을 최대한 활용하는 것입니다. 그의 결과는 무차별 대입 솔루션이 실현 가능 하다는 것을 암시합니다 . 와일드 카드를 포함하여 결국 7 개의 문자로 만들 수 있는 최대 단어가 있으며 그 중 1/10000 미만 (약 백만 개)으로 표시됩니다. 유효한 단어를 포함시키지 마십시오. $27^7 = 10,460,353,203$

첫 번째 단계는 와일드 카드 문자 "?"로 최소 사전을 보강하는 것입니다. 22 개의 글자가 두 글자로 표시됩니다 (c, q, v, z 제외). 22 개의 문자에 와일드 카드를 연결하여 사전에 추가합니다 : {a ?, b ?, d ?, ..., y?}가 이제 입력되었습니다. 마찬가지로 최소 3 글자 단어를 검사하여 추가 단어를 생성 할 수 있습니다. 사전에 나타납니다. 마지막으로 "??"를 추가합니다 사전에. 반복되는 결과를 제거한 후 최소 342 개의 단어가 포함됩니다.

아주 적은 양의 인코딩을 실제로 사용하는 우아한 방법은 이 문제를 대수적으로 보는 것 입니다. 정렬되지 않은 문자 집합으로 간주되는 단어는 단지 일식입니다. 예를 들어, "spats"는 단수 입니다. 따라서 사전은 모노 미아 모음입니다. 마치$a p s^2 t$

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

(혼동을 피하기 위해 와일드 카드 문자에 를 썼습니다 ).$\psi$

해당 단어가 랙을 나누는 경우에만 유효한 단어가 랙에 포함됩니다.

더 추상적이지만 매우 강력한 방법은 사전 이 다항식 링 R = Z [ a , b , … , z , ψ ] 에서 이상적인 을 생성하고 유효한 단어가있는 랙이 몫에서 0이된다는 것입니다. 링 R은 / 나는 , 반면에 올바른 단어가없는 랙 몫에 제로 남아있다. 우리가 R 에서 모든 랙의 합을 형성 하고이 몫 고리에서 계산하면 단어가없는 랙의 수는 몫의 고유 한 모노 수의 수와 같습니다.$I$$R = \mathbb{Z}[a, b, \ldots, z, \psi]$$R/I$$R$

또한 의 모든 랙의 합계 는 간단합니다. α = a + b + ⋯ + z + ψ를 알파벳의 모든 문자의 합 이라고합시다 . α 7 에는 각 랙마다 하나의 모노가 포함되어 있습니다. (추가 보너스로서, 계수는 각 랙을 구성 할 수있는 방법의 수를 계산하여 원하는 경우 확률을 계산할 수 있습니다.)$R$$\alpha = a + b + \cdots + z + \psi$$\alpha^7$

간단한 예 (이것이 어떻게 작동하는지보기 위해), (a) 와일드 카드를 사용하지 않고 (b) "a"에서 "x"까지의 모든 문자를 단어로 간주한다고 가정하십시오. 그런 다음 단어를 만들 수없는 가능한 랙은 모두 y와 z로 구성되어야합니다. 우리는 한 번에 한 단계 씩 { a , b , c , … , x }에 의해 생성 된 이상을 모듈로 계산합니다 .$\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{.} }$$

우리는 최종 답변에서 비 워드 랙을 얻는 기회를 읽을 수 : 각 계수는 해당 랙을 그리는 방법을 계산합니다. 예를 들어, y의 계수 때문에 2 개의 y와 5 개의 z를 그리는 21 가지 방법 (26 ^ 7 개 중) $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과 같습니다.$y^2 z^5$

기초 계산에서 이것이 정답이라는 것이 분명합니다. 요점은이 절차가 사전의 내용에 관계없이 작동한다는 것입니다.

각 단계에서 이상적인 전력 모듈로 감소가 계산을 줄이는 방법에 주목하십시오. 이것이 바로이 접근법에 의해 드러난 바로 가기입니다. (예시)

다항식 대수 시스템은 이러한 계산을 구현합니다 . 예를 들어 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]

(사전은 @vqv의 min.dict에서 간단하게 구성 할 수 있습니다. 원하는 경우 직접 지정할 수있을 정도로 짧다는 것을 나타내는 줄을 여기에 넣습니다.)

10 분의 계산 시간이 걸리는 출력은 577958입니다. ( NB 이 메시지의 이전 버전에서 나는 사전을 준비하는 데 약간의 실수를했고 577940을 얻었습니다. 나는 현재 원하는 것을 반영하도록 텍스트를 편집했습니다. 정확한 결과!) 예상했던 백만 개 정도의 작은 값이지만 같은 크기입니다.

그러한 랙을 얻을 가능성 을 계산하려면 랙을 그릴 수있는 방법의 수를 고려해야합니다. 예제에서 보았 듯이 이것은 계수가 것과 같습니다 . 도면의 기회 일부 이러한 랙은 1과 동일 쉽게 모든 문자를 설정하여 볼 모든 계수의 합이다 :$\alpha^7$

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

정답은 1066056120으로, 유효한 단어를 만들 수없는 랙을 그릴 때 10.1914 %의 확률을 제공합니다 (모든 문자가 똑같이 가능할 경우).

글자의 확률이 다를 경우 각 글자를 그릴 가능성으로 바꾸십시오.

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)

출력은 1.079877553303 %이며 정확한 답변입니다 ( 대체 모델을 사용 하더라도 교체 하여 그리기 ). 다시 찾고, 그것은 일을하기 위해 데이터 (알파벳, 사전 및 알파벳 주파수) 만 세 줄을 입력 할 네 줄을했다 :의 다음 동력 인출하는 방법에 대해 설명 모듈 I를 , 재귀 7 전원을, 그리고 대체 글자의 확률.$\alpha$$I$

글자 맞추기와 그 변형에 유효한 단어가 포함되지 않은 랙을 그리는 것은 매우 어렵습니다. 아래는 초기 7 타일 랙에 유효한 단어가 포함되지 않을 확률을 추정하기 위해 작성한 R 프로그램입니다. 그것은 몬테 카를로 접근법과 친구와 함께하는 단어 사전을 사용합니다 (공식적인 글자 맞추기 사전을 쉬운 형식으로 찾을 수 없었습니다). 각 시험판은 7 타일 랙을 그린 다음 랙에 유효한 단어가 포함되어 있는지 확인합니다.

최소 단어

랙에 유효한 단어가 포함되어 있는지 확인하기 위해 전체 사전을 스캔 할 필요는 없습니다. 최소한의 단어 로 구성된 최소한의 사전 을 스캔 하면됩니다. 단어에 하위 단어로 다른 단어가 포함되어 있지 않으면 단어가 최소화됩니다. 예를 들어 'em'은 최소한의 단어입니다. '빈'은 아닙니다. 요점은 랙에 단어 x가 포함 된 경우 x의 하위 집합도 포함해야한다는 것 입니다. 다시 말해, 랙에는 최소 단어가 포함되어 있지 않으면 단어가 포함되지 않습니다. 운 좋게도 어휘집의 대부분의 단어는 최소가 아니므로 제거 할 수 있습니다. 순열 등가 단어를 병합 할 수도 있습니다. 나는 친구들과 함께하는 단어 사전을 172,820에서 201 개의 최소 단어로 줄일 수있었습니다.

랙과 단어를 문자의 분포로 취급하여 와일드 카드를 쉽게 처리 할 수 ​​있습니다. 한 분포에서 다른 분포를 빼서 랙에 단어가 포함되어 있는지 확인합니다. 이것은 랙에서 누락 된 각 문자의 수를 제공합니다. 그 수의 합이 경우 와일드 카드의 개수는, 그 단어는 랙이다.$\leq$

몬테 카를로 접근법의 유일한 문제는 우리가 관심을 갖는 사건이 매우 드물다는 것입니다. 따라서 충분히 작은 표준 오차로 추정값을 얻으려면 많은 시도가 필요합니다. 나는 시험으로 내 프로그램을 (바닥에 붙여) 실행 했으며 초기 랙에 유효한 단어가 포함되어 있지 않을 확률은 0.004입니다 . 해당 추정치의 추정 표준 오차는 0.0002입니다. 어휘집 다운로드를 포함하여 Mac Pro에서 실행하는 데 몇 분 밖에 걸리지 않았습니다.$N=100,000$

누군가가 효율적인 정확한 알고리즘을 만들 수 있는지 알고 싶습니다. 포함 제외에 기반한 순진한 접근 방식은 조합 폭발이 수반되는 것처럼 보입니다.

포함 제외

나는 이것이 나쁜 해결책이라고 생각하지만, 여기에 불완전한 스케치가 있습니다. 원칙적으로 계산을 수행하는 프로그램을 작성할 수 있지만 사양은 비참합니다.

계산할 확률은 우측의 확률 내부 이벤트가 이벤트의 조합이다 : P ( K 랙 -tile 단어를 포함 ) = P ( ∪ X ∈ M이 { k는 -tile 랙 포함하는  X } ) ,

$$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$최소한의 어휘입니다. 포함 제외 수식을 사용하여 확장 할 수 있습니다. 그것은 위의 사건들의 가능한 모든 교차점을 고려하는 것을 포함합니다. 하자 의 힘 세트 나타내는 M 의 가능한 모든 부분 집합의 예 세트 M을 . 그때 $\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$

그때

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

I'm going to stop here, because the expansions are tortuous to write out and not at all enlightening. It's easier to write a computer program to do it. But by now you should see that the inclusion-exclusion approach is intractable. It involves $2^{|M|}$ terms, each of which is also very complicated. For the lexicon I considered above $2^{|M|} \approx 3.2 \times 10^{60}$.

Scanning all possible racks

I think this is computationally easier, because there are fewer possible racks than possible subsets of minimal words. We successively reduce the set of possible $k$-tile racks until we get the set of racks which contain no words. For Scrabble (or Words With Friends) the number of possible 7-tile racks is in the tens of billions. Counting the number of those that do not contain a possible word should be doable with a few dozen lines of R code. But I think you should be able to do better than just enumerating all possible racks. For instance, 'aa' is a minimal word. That immediately eliminates all racks containing more than one 'a’. You can repeat with other words. Memory shouldn’t be an issue for modern computers. A 7-tile Scrabble rack requires fewer than 7 bytes of storage. At worst we would use a few gigabytes to store all possible racks, but I don’t think that’s a good idea either. Someone may want to think more about this.

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)), ")")

Srikant is right: a Monte Carlo study is the way to go. There are two reasons. First, the answer depends strongly on the structure of the dictionary. Two extremes are (1) the dictionary contains every possible single-letter word. In this case, the chance of not making a word in a draw of $1$ or more letters is zero. (2) The dictionary contains only words formed out of a single letter (e.g., "a", "aa", "aaa", etc.). The chance of not making a word in a draw of $k$ letters is easily determined and obviously is nonzero. Any definite closed-form answer would have to incorporate the entire dictionary structure and would be a truly awful and long formula.

The second reason is that MC indeed is feasible: you just have to do it right. The preceding paragraph provides a clue: don't just generate words at random and look them up; instead, analyze the dictionary first and exploit its structure.

One way represents the words in the dictionary as a tree. The tree is rooted at the empty symbol and branches on each letter all the way down; its leaves are (of course) the words themselves. However, we can also insert all nontrivial permutations of every word into the tree, too (up to $k!-1$ of them for each word). This can be done efficiently because one does not have to store all those permutations; only the edges in the tree need to be added. The leaves remain the same. In fact, this can be simplified further by insisting that the tree be followed in alphabetical order.

In other words, to determine whether a multiset of $k$ characters is in the dictionary, first arrange the elements into sorted order, then look for this sorted "word" in a tree constructed from the sorted representatives of the words in the original dictionary. This will actually be smaller than the original tree because it merges all sets of words that are sort-equivalent, such as {stop, post, pots, opts, spot}. In fact, in an English dictionary this class of words would never be reached anyway because "so" would be found first. Let's see this in action. The sorted multiset is "opst"; the "o" would branch to all words containing only the letters {o, p, ..., z}, the "p" would branch to all words containing only {o, p, ..., z} and at most one "o", and finally the "s" would branch to the leaf "so"! (I have assumed that none of the plausible candidates "o", "op", "po", "ops", or "pos" are in the dictionary.)

A modification is needed to handle wildcards: I'll let the programmer types among you think about that. It won't increase the dictionary size (it should decrease it, in fact); it will slightly slow down the tree traversal, but without changing it in any fundamental way. In any dictionary that contains a single-letter word, like English ("a", "i"), there is no complication: the presence of a wildcard means you can form a word! (This hints that the original question might not be as interesting as it sounds.)

The upshot is that a single dictionary lookup requires (a) sorting a $k$-letter multiset and (b) traversing no more than $k$ edges of a tree. The running time is $O(k \log(k))$. If you cleverly generate random multisets in sorted order (I can think of several efficient ways to do this), the running time reduces to $O(k)$. Multiply this by the number of iterations to get the total running time.

I bet you could conduct this study with a real Scrabble set and a million iterations in a matter of seconds.

Monte Carlo Approach

The quick and dirty approach is to do a monte carlo study. Draw $k$ tiles $m$ times and for each draw of $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}$$