글자 맞추기에서 한 봉지에서 주어진 단어를 그릴 가능성

타일 이있는 가방이 있고 각각에 글자 가있는 것으로 가정 하십시오. 문자 'A' 가있는 타일, 'B'가있는 등, '와일드 카드'타일이 있습니다 ( ). 한정된 수의 단어가있는 사전이 있다고 가정합니다.$n$$n_A$$n_B$$n_*$$n = n_A + n_B + \ldots + n_Z + n_*$

당신은 선택 교체없이 가방에서 타일을.$k$

타일이 주어진 사전에서 길이 (1 < = < ) 의 주어진 단어를 형성 할 확률을 어떻게 계산 (또는 추정) 하시겠습니까?$l$$l$$k$$k$

Scrabble (TM)에 익숙하지 않은 사용자는 와일드 카드 문자를 사용하여 모든 문자를 일치시킬 수 있습니다. 따라서 'BOOT'라는 단어는 타일 'B', '*', 'O', 'T'로 '맞춤법'이 될 수 있습니다. 문자가 그려지는 순서는 중요하지 않습니다.

제안 : 답안 작성을 단순화하기 위해 질문에 대답하는 것이 좋습니다. 새로운 가방에서 7 글자를 그린 후 가능한 동작 중 'BOOT'라는 단어가있을 확률은 얼마입니까?

(문제 소개는 이와 비슷한 질문 에서 복사되었습니다 )

수식 요구된다. 불행히도 상황은 너무 복잡하여 모든 수식이 모든 가능성을 열거하는 원형 길 일뿐입니다. 대신에,이 답변은 (a) 이항 계수의 곱의 합을 포함하는 공식에 탄탈 가능하고 (b) 많은 플랫폼으로 이식 될 수 있는 알고리즘 을 제공합니다 .

---

이러한 공식을 얻으려면 두 가지 방법으로 가능성을 서로 분리 된 그룹으로 분류 하십시오. 랙에서 단어에 포함 되지 않은 문자 수에 따라 (이것은 ), 선택한 와일드 카드 (공백) 수에 따라 ( 이것이 w ). 이 때 , R = 7 개 랙 타일 N 가능한 타일 M 없는 단어의 글자와 타일 가능하고, W = 2 사용할 블랭크, 주어진 가능한 선택의 수 ( m은 , 승 ) 이고$m$$w$$r=7$$N$$M$$W=2$$(m,w)$

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

비 단어 문자, 공백 및 단어 문자의 선택은 ( m , w , r ) 에 독립적 인 조건부이기 때문에 .$(m,w,r).$

이 단어의 문자를 나타내는 타일에서만 선택할 때 단어를 철자하는 방법의 수를 찾는 문제를 감소 주어진 것을 공백을 사용할 수 있으며, 타일이 선택됩니다. 상황이 지저분하고 닫힌 공식이 없습니다. 예를 들어, 공백과 단어를 벗어난 문자가 그려지면 "b", "o"및 "t"타일에서 가져온 "부팅"을 철자하기 위해 정확히 4 개의 문자가 남습니다. . 감안있다 '의 "B" 의 "O"'및$w$$r-m-w$$w=0$$m=3$$2$$8$$6$"t"는 글자 맞추기 타일 세트에 있으며, 그림 (멀티 세트) "bboo", "bbot", "bbtt", "booo", "boot", "bott", "bttt", "oooo의 긍정적 확률이 있습니다. ","ooot ","oott ","ottt "및"tttt "이지만이 중 하나만"부팅 "입니다. 그리고 그것은 쉬운 경우였습니다! 예를 들어, 랙에 "o", "b"및 "t"타일에서 무작위로 선택된 5 개의 타일이 있고 두 공백과 함께 "부팅"을 철자가 아닌 철자가 많은 방법이 있다고 가정합니다. 예를 들어 "boot"는 "__boott"및 "__bbttt"에서 철자를 입력 할 수 있지만 "__ttttt"는 철자를 지정할 수 없습니다.

문제의 핵심 인이 계산은 재귀 적으로 처리 될 수 있습니다. 예를 들어 설명하겠습니다. "b", "o"및 "t"타일 모음에서 하나의 공백과 4 개의 타일을 사용하여 "부팅"철자법을 세고 싶다고 가정합니다 (나머지 두 타일은 { "b", "o", "t"}). 첫 글자 "b"를 보자.

1. "b"는 사용 가능한 두 개의 "b"타일 에서 방식 으로 그릴 수 있습니다. 이렇게하면 공백과 "o"및 "t"타일 모음에서 세 개의 타일 만 사용하여 접미사 "oot"를 철자하는 방법의 수를 계산하는 문제가 줄어 듭니다.$\binom{2}{1}$

2. 하나의 공백을 "b"로 지정할 수 있습니다. 이렇게하면 나머지 공백과 "o"및 "t"타일 모음에서 3 개 이상의 타일을 사용하여 "oot"철자를 쓰는 방법의 수를 계산하는 문제가 줄어 듭니다.

일반적으로 (1)과 (2) 단계는 분리되어 확률 계산에 추가로 기여합니다. 첫 번째 문자에 사용될 수있는 공백 수에 대한 루프로 구현할 수 있습니다. 감소 된 문제는 재귀 적으로 해결됩니다. 기본 사례는 한 글자가 남았을 때 발생하며, 해당 글자를 가진 특정 수의 타일이 있으며 랙에 공백이있을 수 있습니다. 랙의 빈 공간 수와 사용 가능한 타일 수만으로도 해당 마지막 문자의 원하는 수량을 얻을 수있을 것입니다.

다음은 R재귀 단계의 코드입니다. 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))
}

이 함수에 대한 인터페이스는 표준 Scrabble 타일을 지정하고 주어진 단어를 다중 집합 데이터 구조로 변환하고 과 대해 이중 합을 수행합니다 . 이항 계수 및 이 계산되고 곱해지는 위치입니다.$m$$w$$\binom{M}{m}$$\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)))
}

---

이 솔루션을 시험 해보고 시간을 정해 봅시다. 다음 테스트는 @Rasmus Bååth의 시뮬레이션에 사용 된 것과 동일한 입력을 사용 합니다 .

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

이 기계는 총 경과 시간 초를 보고합니다 . 결과는?$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

"부팅"확률 은 필자의 다른 답변 에서 얻은 의 값과 정확히 같습니다 (유사한 방법을 사용하지만 상징적 인 대수 컴퓨팅 플랫폼을 요구하는 더 강력한 프레임 워크에 포함). 네 단어에 대한 확률 (때문에 자사의 낮은 확률로 '동물학 "에 대한 정확한 값을 제공 할 것으로 예상 할 수없는 합리적으로 가까운 바트의 시뮬레이션에 있습니다 덜 만에 하나보다).$114327888/16007560800$$2381831/333490850$$11840/16007560800,$

참조 된 질문 에 대한 답변 은 여기에 직접 적용됩니다 : 대상 단어 (및 가능한 와일드 카드 철자)로만 구성된 사전을 만들고 임의 랙이 대상을 형성 할 수없는 확률을 계산하고 에서 빼십시오 . 이 계산은 빠릅니다.$1$

시뮬레이션 (끝 부분에 표시)은 계산 된 답변을 지원합니다.

---

세부

이전 답변에서와 같이 Mathematica 는 계산을 수행하는 데 사용됩니다.

1. 문제 (단어, 원하는 경우 단어), 글자, 개수 및 랙 크기를 지정하십시오. 단어에 포함되지 않은 모든 문자가 동일하게 작동하기 때문에 "단어에없는 모든 문자"를 나타내는 단일 기호 모든 문자 를 대체하는 계산 속도가 크게 향상 됩니다.$\chi$

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

2. 이 단어 (또는 단어) 의 사전 을 작성하고 가능한 모든 와일드 카드 철자를 포함하도록이를 보강하십시오.

   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. 비 단어를 계산하십시오.

   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$

   (이 경우 단어가 아닌 단어가 있습니다.)$185$

4. 기회를 계산하십시오. 대체 샘플링으로 변수의 타일 수를 대체하십시오.

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

   $\frac{207263413}{39062500000}$

   이 값은 대략 $0.00756036.$

   교체하지 않고 샘플링하려면 검정력 대신 계승 검정력을 사용하십시오.

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

   이 값은 약 계산은 실질적으로 즉각적이었습니다.$0.00714212.$

---

시뮬레이션 결과

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

표준 오류를 기준으로 계산 된 값과 비교하십시오.

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

$-1.41259$

이 계약은 괜찮으며 계산 결과를 강력하게 지원합니다.

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

비교하십시오 :

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

$0.331106$

이 시뮬레이션의 동의는 훌륭했습니다.

$12$

이것은 몬테카를로 솔루션입니다. 즉, 타일을 여러 번 그려내는 것을 시뮬레이션 한 다음 시뮬레이션 된 드로우 중 몇 개가 주어진 단어를 형성 할 수 있었는지를 계산할 것입니다. R로 솔루션을 작성했지만 Python 또는 Ruby와 같은 다른 프로그래밍 언어를 사용할 수 있습니다.

먼저 하나의 무승부를 시뮬레이트하는 방법을 설명하겠습니다. 먼저 타일 주파수를 정의 해 봅시다.

# 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

그런 다음 단어를 문자 수로 구성된 벡터로 인코딩하십시오.

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 

이제 7 개의 타일 샘플을 그리고 단어와 같은 방식으로 인코딩합니다.

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 

마지막으로 어떤 문자가 누락되었는지 계산하십시오 ...

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 

... 그리고 누락 된 문자 수를 합산하고 사용 가능한 공백 수를 뺍니다. 결과가 0 이하이면 단어 철자에 성공했습니다.

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

이 특별한 경우에 우리는하지 않았습니다 ... 이제 우리는 이것을 여러 번 반복하고 성공적인 추첨 비율을 계산하면됩니다. 이 모든 것은 다음 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)
}

reps시뮬레이션 된 추첨 횟수는 다음과 같습니다 . 이제 여러 단어로 시도해 볼 수 있습니다.

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

$$p_0=\frac{\binom{n_b}{1}\binom{n_o}{2}\binom{n_t}{1}\binom{n-4}{3}}{\binom{n}{7}}$$ $p_k$$k$ $$\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$$

프로젝트를 어떻게 구축했는지 살펴본 지 오래되었습니다. 그리고 내 수학은 아래에서 완전히 틀리거나 정확할 수 있습니다. 거꾸로 가질 수 있습니다. 솔직히 잊어 버립니다. 그러나! 빈 타일을 고려하지 않고 이항 조합 만 사용하면 모든 것을 비틀어 버릴 수 있습니다. 야생없이 간단한 조합 솔루션.

나는이 질문들을 스스로 물었고, 그것 때문에 내 자신의 글자 맞추기 단어 확률 사전을 만들었 습니다. 당신은 가능한 단어 사전을 뽑을 필요가 없으며 그 뒤에있는 수학과 타일 백의 문자를 기반으로 한 사용 가능한 문자 만 필요합니다. 영어 규칙 배열은 다음과 같습니다. 게임에서 사용할 수없는 단어를 포함하여 게임에서 사용할 수있는 모든 영어 단어에 대해이 질문에 답하기 위해 수학을 개발하는 데 몇 주가 걸렸습니다. 모두 잘못되었을 수 있습니다.

글자 맞추기에서 한 글자의 백에서 주어진 단어를 그릴 확률은 각 글자 (AZ)에 대해 백에서 사용할 수있는 글자 수와 수학에 와일드 카드를 사용하는지 여부를 요구합니다. 이 타일에는 100 개의 타일이 있다고 가정하고이 중 2 개는 비어 있다고 가정합니다. 또한 사용 가능한 타일 수는 게임 언어 및 전 세계의 게임 규칙에 따라 다릅니다. 영어 글자 맞추기는 아랍어 글자 맞추기와 다릅니다. 사용 가능한 문자를 변경하면 수학이 작동합니다.

누구든지 오류를 발견하면 업데이트하고 해결해야합니다.

Boot : 글자 맞추기 게임에서 부팅 확률은 0.000386 %이며 부팅 단어 페이지에 표시된대로 173,758 개 중 67 개가 될 가능성이 있습니다.

영어 타일

모두 는 가방에 문자 배열입니다. count 는 해당 문자에 사용 가능한 타일의 배열이며 point 는 문자 의 포인트 값입니다.

// 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");

영어 글자 맞추기 게임 에는 100 개의 타일 이 있습니다 (즉, 합 $count). 타일이 어떻게 당겨 지는지는 중요하지 않으므로 순열이 아닙니다.

내가 사용한 수학 단어에 몇 개의 글자가 있는지, 단어에 어떤 글자가 있는지, 타일 백에서 몇 개의 글자를 사용할 수 있는지 결정합니다 (각 글자 수, 고유 문자 및 allchars). 각각의 이항 계수를 길이 단어의 이항 계수로 나눈 값입니다.

사용 가능한 이항 조합 결정

let C(n,r) be binomial coefficient: n!/[n!(n-r)!], or 0 if r > n

각 문자에는 이항 계수가 무엇입니까?

1 "B"가 있습니다. 2를 사용할 수 있으며 2 % 확률로 b를 당길 수 있습니다.
2 "O"가 있습니다. 8을 사용할 수 있으며, 8 % 확률로 o를 당길 수 있습니다.
1 "T"가 있습니다. 6을 사용할 수 있으며, 6 % 확률로 t를 당길 수 있습니다.
BOOT는 4 글자 단어로, 공백없이 98 개의 타일없이 100 개의 타일 세트에서 가져옵니다.

n = 98. 영어 세트에서 공백이없는 타일 수

$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}$ 타일 ​​수의 이항 계수로 나눈 값 $\frac{98!}{98!(98-{\rm length})!}$