![](\"http://norvig.com/honeycombs.png\")
\n",
"\n", "
![](\"https://fivethirtyeight.com/wp-content/uploads/2020/01/Screen-Shot-2019-12-24-at-5.46.55-PM.png?w=1136\")
\n",
"> \n",
"> The goal is to identify as many words as possible that meet the following criteria:\n",
"> 1. The word must be at least four letters long.\n",
"> 2. The word must include the central letter.\n",
"> 3. The word cannot include any letter beyond the seven given letters.\n",
">\n",
">Note that letters can be repeated. For example, the words GAME and AMALGAM are both acceptable words. Four-letter words are worth 1 point each, while five-letter words are worth 5 points, six-letter words are worth 6 points, seven-letter words are worth 7 points, etc. Words that use all of the seven letters in the honeycomb are known as **pangrams** and earn 7 bonus points (in addition to the points for the length of the word). So in the above example, MEGAPLEX is worth 15 points.\n",
">\n",
"> ***Which seven-letter honeycomb results in the highest possible game score?*** To be a valid choice of seven letters, no letter can be repeated, it must not contain the letter S (that would be too easy) and there must be at least one pangram.\n",
">\n",
"> For consistency, please use [this word list](https://norvig.com/ngrams/enable1.txt) to check your game score.\n",
"\n",
"\n",
"\n",
"Since the referenced [word list](https://norvig.com/ngrams/enable1.txt) came from [*my* web site](https://norvig.com/ngrams/enable1.txt), I felt somewhat compelled to solve this one. (Note I didn't make up the word list; it is a standard Scrabble word list that I happen to host a copy of.) I'll show you how I address the problem, step by step:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Step 1: Words, Word Scores, and Pangrams\n",
"\n",
"Let's start by defining some basics:\n",
"\n",
"- A **valid word** is a string of at least 4 letters, with no 'S', and not more than 7 distinct letters.\n",
"- A **word list** is, well, a list of words.\n",
"- A **pangram** is a word with exactly 7 distinct letters; it scores a **pangram bonus** of 7 points.\n",
"- The **word score** is 1 for a four letter word, or the length of the word for longer words, plus any pangram bonus.\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"from typing import List, Set, Tuple, Dict\n",
"from collections import Counter, defaultdict\n",
"from dataclasses import dataclass\n",
"from itertools import combinations\n",
"import matplotlib.pyplot as plt"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"Word = str # Type for a word\n",
"\n",
"def valid(word) -> bool:\n",
" \"\"\"Does word have at least 4 letters, no 'S', and no more than 7 distinct letters?\"\"\"\n",
" return len(word) >= 4 and 'S' not in word and len(set(word)) <= 7\n",
"\n",
"def valid_words(text, valid=valid) -> List[Word]: \n",
" \"\"\"All the valid words in text.\"\"\"\n",
" return [w for w in text.upper().split() if valid(w)]\n",
"\n",
"def pangram_bonus(word) -> int: \n",
" \"\"\"Does a word get a bonus for having 7 distinct letters?\"\"\"\n",
" return 7 if len(set(word)) == 7 else 0\n",
"\n",
"def word_score(word) -> int: \n",
" \"\"\"The points for this word, including bonus for pangram.\"\"\"\n",
" return 1 if len(word) == 4 else len(word) + pangram_bonus(word)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"I'll make a mini word list to experiment with: "
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['GAME', 'AMALGAM', 'GLAM', 'MEGAPLEX', 'CACCIATORE', 'EROTICA']"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"mini = valid_words('game amalgam amalgamation glam gem gems em megaplex cacciatore erotica')\n",
"mini"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Note that `gem` and `em` are too short, `gems` has an `s` which is not allowed, and `amalgamation` has too many distinct letters (8). We're left with six valid words out of the ten candidate words. Here are examples of the other two functions in action:"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'CACCIATORE', 'EROTICA', 'MEGAPLEX'}"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"{w for w in mini if pangram_bonus(w)}"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'GAME': 1,\n",
" 'AMALGAM': 7,\n",
" 'GLAM': 1,\n",
" 'MEGAPLEX': 15,\n",
" 'CACCIATORE': 17,\n",
" 'EROTICA': 14}"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"{w: word_score(w) for w in mini}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Step 2: Honeycombs and Game Scores\n",
"\n",
"In a honeycomb the order of the letters doesn't matter; all that matters is:\n",
" 1. The seven distinct letters in the honeycomb.\n",
" 2. The one distinguished center letter.\n",
" \n",
"Thus, we can represent a honeycomb as follows:\n",
" "
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Honeycomb(letters='AEGLMPX', center='G')"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"@dataclass(frozen=True, order=True)\n",
"class Honeycomb:\n",
" letters: str # 7 letters\n",
" center: str # 1 letter\n",
"\n",
"hc = Honeycomb('AEGLMPX', 'G')\n",
"hc"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The **game score** for a honeycomb is the sum of the word scores for all the words that the honeycomb can make. How do we know if a honeycomb can make a word? It can if (1) the word contains the honeycomb's center and (2) every letter in the word is in the honeycomb. "
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"def game_score(honeycomb, wordlist) -> int:\n",
" \"\"\"The total score for this honeycomb.\"\"\"\n",
" return sum(word_score(w) \n",
" for w in wordlist if can_make(honeycomb, w))\n",
"\n",
"def can_make(honeycomb, word) -> bool:\n",
" \"\"\"Can the honeycomb make this word?\"\"\"\n",
" return honeycomb.center in word and all(L in honeycomb.letters for L in word)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"24"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"game_score(hc, mini)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'GAME': 1, 'AMALGAM': 7, 'GLAM': 1, 'MEGAPLEX': 15}"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"{w: word_score(w) for w in mini if can_make(hc, w)}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Step 3: Best Honeycomb\n",
"\n",
"Now that we can compute the game score of a honeycomb, a strategy for finding the best honeycomb is:\n",
" - Compile a list of valid candidate honeycombs.\n",
" - For each one, compute the game score.\n",
" - Return the one with the highest game score."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"def best_honeycomb(words) -> Honeycomb: \n",
" \"\"\"Return a honeycomb with highest game score on these words.\"\"\"\n",
" return max(valid_honeycombs(words), \n",
" key=lambda h: game_score(h, words))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"What are the possible candidate honeycombs? We can put any letter in the center, then any 6 letters around the outside (order doesn't matter); since the letter 'S' is not allowed, this gives a total of 25 × (24 choose 6) = 3,364,900 possible honeycombs. \n",
"\n",
"However, a key constraint of the game is that a valid honeycomb **must make at least one pangram**. That means that a valid honeycomb must ***be*** the set of seven letters in a pangram (with any of the seven letters as the center). There should be fewer than 3,364,900 of these."
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"def valid_honeycombs(words) -> List[Honeycomb]:\n",
" \"\"\"Valid Honeycombs are the pangram lettersets, with any center.\"\"\"\n",
" pangram_lettersets = {letterset(w) for w in words if pangram_bonus(w)}\n",
" return [Honeycomb(letters, center) \n",
" for letters in pangram_lettersets \n",
" for center in letters]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"I will represent a **set of letters** as a sorted string of distinct letters. Why not a Python `set` (or `frozenset` to be hashable)? Because a string takes up less space in memory, and its printed representation is easier to read when debugging. Compare:\n",
"- `frozenset({'A', 'E', 'G', 'L', 'M', 'P', 'X'})`\n",
"- `'AEGLMPX'`\n",
"\n",
"I'll use the name `letterset` for the function that converts a word to a set of letters, and `Letterset` for the resulting type:"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"Letterset = str # Type for a set of letters, like \"AGLM\"\n",
"\n",
"def letterset(word) -> Letterset:\n",
" \"\"\"The set of letters in a word, represented as a sorted str.\"\"\"\n",
" return ''.join(sorted(set(word)))"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'GAME': 'AEGM',\n",
" 'AMALGAM': 'AGLM',\n",
" 'GLAM': 'AGLM',\n",
" 'MEGAPLEX': 'AEGLMPX',\n",
" 'CACCIATORE': 'ACEIORT',\n",
" 'EROTICA': 'ACEIORT'}"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"{w: letterset(w) for w in mini}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Note that 'AMALGAM' and 'GLAM' have the same letterset, as do 'CACCIATORE' and 'EROTICA'."
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[Honeycomb(letters='ACEIORT', center='A'),\n",
" Honeycomb(letters='ACEIORT', center='C'),\n",
" Honeycomb(letters='ACEIORT', center='E'),\n",
" Honeycomb(letters='ACEIORT', center='I'),\n",
" Honeycomb(letters='ACEIORT', center='O'),\n",
" Honeycomb(letters='ACEIORT', center='R'),\n",
" Honeycomb(letters='ACEIORT', center='T'),\n",
" Honeycomb(letters='AEGLMPX', center='A'),\n",
" Honeycomb(letters='AEGLMPX', center='E'),\n",
" Honeycomb(letters='AEGLMPX', center='G'),\n",
" Honeycomb(letters='AEGLMPX', center='L'),\n",
" Honeycomb(letters='AEGLMPX', center='M'),\n",
" Honeycomb(letters='AEGLMPX', center='P'),\n",
" Honeycomb(letters='AEGLMPX', center='X')]"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"valid_honeycombs(mini)"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Honeycomb(letters='ACEIORT', center='A')"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"best_honeycomb(mini)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**We're done!** We know how to find the best honeycomb. But so far, we've only done it for the mini word list. \n",
"\n",
"# Step 4: The enable1 Word List\n",
"\n",
"Here's the real word list, `enable1.txt`, and some counts derived from it:"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" 172820 enable1.txt\r\n"
]
}
],
"source": [
"! [ -e enable1.txt ] || curl -O http://norvig.com/ngrams/enable1.txt\n",
"! wc -w enable1.txt"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"44585"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"enable1 = valid_words(open('enable1.txt').read())\n",
"len(enable1)"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"14741"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pangrams = [w for w in enable1 if pangram_bonus(w)]\n",
"len(pangrams)"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"7986"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"len({letterset(w) for w in pangrams}) # pangram lettersets"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"55902"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"len(valid_honeycombs(enable1))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To summarize, there are:\n",
"\n",
"- 172,820 words in the `enable1` word list\n",
"- 44,585 valid Spelling Bee words\n",
"- 14,741 pangram words \n",
"- 7,986 distinct pangram lettersets\n",
"- 55,902 (7 × 7,986) valid pangram-containing honeycombs\n",
"- 3,364,900 possible honeycombs (most of which can't make a panagram and thus are invalid)\n",
"\n",
"How long will it take to run `best_honeycomb(enable1)`? Most of the computation time is in `game_score` (each call has to look at all 44,585 valid words), so let's estimate the total time by first checking how long it takes to compute the game score of a single honeycomb:"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"8.7 ms ± 96.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
]
}
],
"source": [
"%timeit game_score(hc, enable1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Roughly 9 milliseconds on my computer (this may vary). How many seconds would it be to run `game_score` for all 55,902 valid honeycombs?"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"503.118"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"55902 * 9/1000"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"About 500 seconds, or 8 minutes. I could run `best_honeycomb(enable1)`, go take a coffee break, and come back to see the solution and declare victory. But I think that a puzzle like this deserves a more elegant solution. I'd like to get the run time under a minute (as is suggested in [Project Euler](https://projecteuler.net/)), and I have an idea how to do it. (*Note:* I should point out that [William Shunn](https://www.shunn.net/about.html) has a list of [58,838 pangrams](https://www.shunn.net/bee/pangrams.html) that form 20,597 distinct pangram lettersets, so it would take more than twice as long with his dictionary. However, we don't know what dictionary the NY Times is using, so we don't know what words would be accepted.)\n",
"\n",
"# Step 5: Faster Algorithm: Points Table\n",
"\n",
"Here's my plan for a more efficient program:\n",
"\n",
"1. Keep the same strategy of trying every pangram letterset, but do some precomputation that will make `game_score` much faster.\n",
"1. The precomputation is: compute the `letterset` and `word_score` for each word, and make a table of `{letterset: total_points}` giving the total number of word score points for all the words that correspond to each letterset. I call this a **points table**.\n",
"3. These calculations are independent of the honeycomb, so they need be done only once, not 55,902 times. \n",
"4. `game_score2` takes a honeycomb and a points table as input. The idea is that every word that the honeycomb can make must have a letterset that is the same as a valid **letter subset** of the honeycomb. A valid letter subset must include the center letter, and it may or may not include each of the other 6 letters, so there are exactly $2^6 = 64$ valid letter subsets. The function `letter_subsets(honeycomb)` computes these.\n",
"The result of `game_score2` is the sum of the honeycomb's 64 letter subset entries in the points table.\n",
"\n",
"That means that in `game_score2` we no longer need to iterate over 44,585 words and check if each word is a subset of the honeycomb. Instead we iterate over the 64 subsets of the honeycomb and for each one check—in one table lookup—whether it is a word (or more than word) and how many total points those word(s) score. Since 64 is less than 44,585, that's a nice optimization!\n",
"\n",
"\n",
"Here's the code:"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [],
"source": [
"PointsTable = Dict[Letterset, int] # How many points does a letterset score?\n",
"\n",
"def best_honeycomb(words) -> Honeycomb: \n",
" \"\"\"Return a honeycomb with highest game score on these words.\"\"\"\n",
" points_table = tabulate_points(words)\n",
" honeycombs = (Honeycomb(letters, center) \n",
" for letters in points_table if len(letters) == 7 \n",
" for center in letters)\n",
" return max(honeycombs, key=lambda h: game_score2(h, points_table))\n",
"\n",
"def tabulate_points(words) -> PointsTable:\n",
" \"\"\"Return a Counter of {letterset: points} from words.\"\"\"\n",
" table = Counter()\n",
" for w in words:\n",
" table[letterset(w)] += word_score(w)\n",
" return table\n",
"\n",
"def letter_subsets(honeycomb) -> List[Letterset]:\n",
" \"\"\"The 64 subsets of the letters in the honeycomb, each including the center letter.\"\"\"\n",
" return [letters \n",
" for n in range(1, 8) \n",
" for letters in map(''.join, combinations(honeycomb.letters, n))\n",
" if honeycomb.center in letters]\n",
"\n",
"def game_score2(honeycomb, points_table) -> int:\n",
" \"\"\"The total score for this honeycomb, using a points table.\"\"\"\n",
" return sum(points_table[letterset] for letterset in letter_subsets(honeycomb))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's get a feel for how this works. \n",
"\n",
"First consider `letter_subsets`. A 4-letter honeycomb makes $2^3 = 8$ subsets; 7-letter honeycombs make $2^6 = 64$ subsets:"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['G', 'GL', 'GA', 'GM', 'GLA', 'GLM', 'GAM', 'GLAM']"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"letter_subsets(Honeycomb('GLAM', 'G')) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now `tabulate_points`:"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"mini = ['GAME', 'AMALGAM', 'GLAM', 'MEGAPLEX', 'CACCIATORE', 'EROTICA']\n"
]
},
{
"data": {
"text/plain": [
"Counter({'AEGM': 1, 'AGLM': 8, 'AEGLMPX': 15, 'ACEIORT': 31})"
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"print('mini =', mini)\n",
"tabulate_points(mini)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The letterset `'AGLM'` gets 8 points, 7 for AMALGAM and 1 for GLAM. `'ACEIORT'` gets 31 points, 17 for CACCIATORE and 14 for EROTICA. The other lettersets represent one word each. \n",
"\n",
"Let's make sure we haven't broken the `best_honeycomb` function:"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [],
"source": [
"assert best_honeycomb(mini) == Honeycomb('ACEIORT', 'A')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Step 6: The Solution"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Finally, the solution to the puzzle:"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 1.65 s, sys: 2.19 ms, total: 1.65 s\n",
"Wall time: 1.65 s\n"
]
}
],
"source": [
"%time best = best_honeycomb(enable1)"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(Honeycomb(letters='AEGINRT', center='R'), 3898)"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"best, game_score(best, enable1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Wow! 3898 is a high score!** \n",
"\n",
"And it took **less than 2 seconds** of computation to find the best honeycomb!\n",
"\n",
"Where does the time go? There's the initial time to do `tabulate_points` once, and then calls to `game_score2` for each candidate honeycomb: "
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 66.1 ms, sys: 852 µs, total: 66.9 ms\n",
"Wall time: 66.2 ms\n"
]
}
],
"source": [
"%time points_table = tabulate_points(enable1)"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"25.6 µs ± 149 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
]
}
],
"source": [
"%timeit game_score2(Honeycomb('AEGINRT', 'R'), points_table)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Step 7: Even Faster Algorithm: Branch and Bound\n",
"\n",
"A run time of less than 2 seconds is pretty good! But I'm not ready to stop now.\n",
"\n",
"Consider the word 'EQUIVOKE'. It is a pangram, but what with the 'Q' and 'V' and 'K', it is not a high-scoring honeycomb, regardless of what center is used:"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'E': 48, 'I': 32, 'K': 34, 'O': 36, 'Q': 29, 'U': 29, 'V': 35}"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"letters = letterset('EQUIVOKE')\n",
"{C: game_score(Honeycomb(letters, C), enable1) for C in letters}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"It would be great if we could eliminate all seven of these honeycombs at once, rather than trying each one in turn. So my idea is to:\n",
"- Keep track of the best honeycomb and best score found so far.\n",
"- For each new pangram letterset, ask \"if we weren't required to use the center letter, would this letterset score higher than the best honeycomb so far?\" \n",
"- If yes, then try it with all seven centers; if not then discard it immediately.\n",
"- This is called a [**branch and bound**](https://en.wikipedia.org/wiki/Branch_and_bound) algorithm: if an **upper bound** of the new letterset's score can't beat the best honeycomb so far, then we prune a whole **branch** of the search tree consisting of the seven honeycombs that have that letterset.\n",
"\n",
"What would the score of a letterset be if we weren't required to use the center letter? It turns out I can make a dummy Honeycomb and specify the empty string for the center, `Honeycomb(letters, '')`, and call `game_score2` on that. This works because of a quirk of Python: we ask if `honeycomb.center in letters`; normally in Python the expression `x in y` means \"is `x` a member of the collection `y`\", but when `y` is a string it means \"is `x` a substring of `y`\", and the empty string is a substring of every string. (If I had represented a letterset as a Python `set`, this wouldn't work.)\n",
"\n",
"Thus, I can rewrite `best_honeycomb` as follows:"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [],
"source": [
"def best_honeycomb2(words) -> Honeycomb: \n",
" \"\"\"Return a honeycomb with highest game score on these words.\"\"\"\n",
" points_table = tabulate_points(words)\n",
" best, best_score = None, 0\n",
" pangrams = (s for s in points_table if len(s) == 7)\n",
" for p in pangrams:\n",
" if game_score2(Honeycomb(p, ''), points_table) > best_score:\n",
" for center in p:\n",
" honeycomb = Honeycomb(p, center)\n",
" score = game_score2(honeycomb, points_table)\n",
" if score > best_score:\n",
" best, best_score = honeycomb, score\n",
" return best"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 373 ms, sys: 1.32 ms, total: 374 ms\n",
"Wall time: 374 ms\n"
]
},
{
"data": {
"text/plain": [
"Honeycomb(letters='AEGINRT', center='R')"
]
},
"execution_count": 33,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"%time best_honeycomb2(enable1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Same honeycomb for the answer, but four times faster–less than 0.4 second.\n",
"\n",
"# Step 8: Curiosity\n",
"\n",
"I'm curious about a bunch of things.\n",
"\n",
"### What's the highest-scoring individual word?"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'ANTITOTALITARIAN'"
]
},
"execution_count": 34,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"max(enable1, key=word_score)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### What are some of the pangrams?"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['AARDWOLF',\n",
" 'ANCIENTER',\n",
" 'BABBLEMENT',\n",
" 'BIVARIATE',\n",
" 'CABEZON',\n",
" 'CHEERFUL',\n",
" 'COLLOGUING',\n",
" 'CRANKLE',\n",
" 'DEMERGERING',\n",
" 'DWELLING',\n",
" 'ETYMOLOGY',\n",
" 'FLATTING',\n",
" 'GARROTTING',\n",
" 'HANDIER',\n",
" 'IDENTIFY',\n",
" 'INTERVIEWER',\n",
" 'LARVICIDAL',\n",
" 'MANDRAGORA',\n",
" 'MORTGAGEE',\n",
" 'NOTABLE',\n",
" 'OVERHELD',\n",
" 'PERONEAL',\n",
" 'PRAWNED',\n",
" 'QUILTER',\n",
" 'REINITIATED',\n",
" 'TABLEFUL',\n",
" 'TOWHEAD',\n",
" 'UNCHURCHLY',\n",
" 'UTOPIAN',\n",
" 'WINDAGE']"
]
},
"execution_count": 35,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pangrams[::500] # Every five-hundreth pangram"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### What's the breakdown of reasons why words are invalid?"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[('too many distinct letters', 73611),\n",
" ('contains an S', 53556),\n",
" ('valid', 44585),\n",
" ('too short', 1068)]"
]
},
"execution_count": 36,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def common(items): return Counter(items).most_common()\n",
"\n",
"common('too short' if len(w) < 4 else \n",
" 'too many distinct letters' if len(set(w)) > 7 else \n",
" 'contains an S' if 'S' in w else\n",
" 'valid'\n",
" for w in valid_words(open('enable1.txt').read(), lambda w: True))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"There are more words with an 'S' than there are valid words.\n",
"\n",
"### About the points table: How many different letter subsets are there? "
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"21661"
]
},
"execution_count": 37,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pts = tabulate_points(enable1)\n",
"len(pts)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"That means there's about two valid words for each letterset.\n",
"\n",
"### Which letter subsets score the most?"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[('AEGINRT', 832),\n",
" ('ADEGINR', 486),\n",
" ('ACILNOT', 470),\n",
" ('ACEINRT', 465),\n",
" ('CEINORT', 398),\n",
" ('AEGILNT', 392),\n",
" ('AGINORT', 380),\n",
" ('ADEINRT', 318),\n",
" ('CENORTU', 318),\n",
" ('ACDEIRT', 307)]"
]
},
"execution_count": 38,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pts.most_common(10)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The best honeycomb, `'AEGINRT'`, is also the highest scoring letter subset on its own (although it only gets 832 of the 3,898 total points from using all seven letters)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### How many honeycombs does `best_honeycomb2` consider?\n",
"\n",
"We know that `best_honeycomb` considers 7,986 × 7 = 55,902 honeycombs. How many does `best_honeycomb2` consider? We can answer that by wrapping `Honeycomb` with a decorator that counts calls:"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"8084"
]
},
"execution_count": 39,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def call_counter(fn):\n",
" \"Return a function that calls fn, and increments a counter on each call.\"\n",
" def wrapped(*args, **kwds):\n",
" wrapped.call_counter += 1\n",
" return fn(*args, **kwds)\n",
" wrapped.call_counter = 0\n",
" return wrapped\n",
" \n",
"Honeycomb = call_counter(Honeycomb)\n",
"\n",
"best = best_honeycomb2(enable1)\n",
"Honeycomb.call_counter"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Only 8,084 honeycombs are considered. That means that most pangrams are only considered once; for only 14 pangrams do we consider all seven centers."
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"14.0"
]
},
"execution_count": 40,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(8084 - 7986) / 7"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Step 9: Fancy Report\n",
"\n",
"I'd like to see the actual words that each honeycomb can make, in addition to the total score, and I'm curious about how the words are divided up by letterset. Here's a function to provide such a report. I remembered that there is a `fill` function in Python (it is in the `textwrap` module) but this turned out to be a lot more complicated than I expected. I guess it is difficult to create a practical extraction and reporting tool. I feel you, [Larry Wall](http://www.wall.org/~larry/)."
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {},
"outputs": [],
"source": [
"from textwrap import fill\n",
"\n",
"def report(honeycomb=None, words=enable1):\n",
" \"\"\"Print stats, words, and word scores for the given honeycomb (or the best\n",
" honeycomb if no honeycomb is given) over the given word list.\"\"\"\n",
" bins = group_by(words, letterset)\n",
" adj = (\"Best \" if honeycomb is None else \"\")\n",
" honeycomb = honeycomb or best_honeycomb(words)\n",
" points = game_score(honeycomb, words)\n",
" subsets = letter_subsets(honeycomb)\n",
" nwords = sum(len(bins[s]) for s in subsets)\n",
" print(f'{adj}{honeycomb} scores {Ns(points, \"point\")} on {Ns(nwords, \"word\")}',\n",
" f'from a {len(words)} word list:\\n')\n",
" for s in sorted(subsets, key=lambda s: (-len(s), s)):\n",
" if bins[s]:\n",
" pts = sum(word_score(w) for w in bins[s])\n",
" wcount = Ns(len(bins[s]), \"pangram\" if len(s) == 7 else \"word\")\n",
" intro = f'{s:>7} {Ns(pts, \"point\"):>10} {wcount:>8} '\n",
" words = [f'{w}({word_score(w)})' for w in sorted(bins[s])]\n",
" print(fill(' '.join(words), width=110, \n",
" initial_indent=intro, subsequent_indent=' '*8))\n",
" \n",
"def Ns(n, noun):\n",
" \"\"\"A string with `n` followed by the plural or singular of noun:\n",
" Ns(3, 'bear') => '3 bears'; Ns(1, 'world') => '1 world'\"\"\" \n",
" return f\"{n:d} {noun}{' ' if n == 1 else 's'}\"\n",
"\n",
"def group_by(items, key):\n",
" \"Group items into bins of a dict, each bin keyed by key(item).\"\n",
" bins = defaultdict(list)\n",
" for item in items:\n",
" bins[key(item)].append(item)\n",
" return bins"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Honeycomb(letters='AEGLMPX', center='G') scores 24 points on 4 words from a 6 word list:\n",
"\n",
"AEGLMPX 15 points 1 pangram MEGAPLEX(15)\n",
" AEGM 1 point 1 word GAME(1)\n",
" AGLM 8 points 2 words AMALGAM(7) GLAM(1)\n"
]
}
],
"source": [
"report(hc, mini)"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {
"scrolled": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Best Honeycomb(letters='AEGINRT', center='R') scores 3898 points on 537 words from a 44585 word list:\n",
"\n",
"AEGINRT 832 points 50 pangrams AERATING(15) AGGREGATING(18) ARGENTINE(16) ARGENTITE(16) ENTERTAINING(19)\n",
" ENTRAINING(17) ENTREATING(17) GARNIERITE(17) GARTERING(16) GENERATING(17) GNATTIER(15) GRANITE(14)\n",
" GRATINE(14) GRATINEE(15) GRATINEEING(18) GREATENING(17) INGRATE(14) INGRATIATE(17) INTEGRATE(16)\n",
" INTEGRATING(18) INTENERATING(19) INTERAGE(15) INTERGANG(16) INTERREGNA(17) INTREATING(17)\n",
" ITERATING(16) ITINERATING(18) NATTERING(16) RATTENING(16) REAGGREGATING(20) REATTAINING(18)\n",
" REGENERATING(19) REGRANTING(17) REGRATING(16) REINITIATING(19) REINTEGRATE(18) REINTEGRATING(20)\n",
" REITERATING(18) RETAGGING(16) RETAINING(16) RETARGETING(18) RETEARING(16) RETRAINING(17)\n",
" RETREATING(17) TANGERINE(16) TANGIER(14) TARGETING(16) TATTERING(16) TEARING(14) TREATING(15)\n",
" AEGINR 270 points 35 words AGINNER(7) AGREEING(8) ANEARING(8) ANERGIA(7) ANGERING(8) ANGRIER(7) ARGININE(8)\n",
" EARING(6) EARNING(7) EARRING(7) ENGRAIN(7) ENGRAINING(10) ENRAGING(8) GAINER(6) GANGRENING(10)\n",
" GARNERING(9) GEARING(7) GRAINER(7) GRAINIER(8) GRANNIE(7) GREGARINE(9) NAGGIER(7) NEARING(7)\n",
" RANGIER(7) REAGIN(6) REARING(7) REARRANGING(11) REEARNING(9) REENGAGING(10) REGAIN(6) REGAINER(8)\n",
" REGAINING(9) REGEARING(9) REGINA(6) REGINAE(7)\n",
" AEGIRT 34 points 5 words AIGRET(6) AIGRETTE(8) GAITER(6) IRRIGATE(8) TRIAGE(6)\n",
" AEGNRT 94 points 13 words ARGENT(6) GARNET(6) GENERATE(8) GRANTEE(7) GRANTER(7) GREATEN(7) NEGATER(7)\n",
" REAGENT(7) REGENERATE(10) REGNANT(7) REGRANT(7) TANAGER(7) TEENAGER(8)\n",
" AEINRT 232 points 30 words ARENITE(7) ATTAINER(8) ENTERTAIN(9) ENTERTAINER(11) ENTRAIN(7) ENTRAINER(9)\n",
" INERRANT(8) INERTIA(7) INERTIAE(8) INTENERATE(10) INTREAT(7) ITERANT(7) ITINERANT(9) ITINERATE(9)\n",
" NATTIER(7) NITRATE(7) RATINE(6) REATTAIN(8) REINITIATE(10) RETAIN(6) RETAINER(8) RETINA(6) RETINAE(7)\n",
" RETIRANT(8) RETRAIN(7) TERRAIN(7) TERTIAN(7) TRAINEE(7) TRAINER(7) TRIENNIA(8)\n",
" AGINRT 167 points 21 words AIRTING(7) ATTIRING(8) GRANITA(7) GRANTING(8) GRATIN(6) GRATING(7)\n",
" INGRATIATING(12) INTRIGANT(9) IRRIGATING(10) IRRITATING(10) NARRATING(9) NITRATING(9) RANTING(7)\n",
" RATING(6) RATTING(7) TARING(6) TARRING(7) TARTING(7) TITRATING(9) TRAINING(8) TRIAGING(8)\n",
" EGINRT 218 points 26 words ENGIRT(6) ENTERING(8) GETTERING(9) GITTERN(7) GREETING(8) IGNITER(7) INTEGER(7)\n",
" INTERNING(9) INTERRING(9) REENTERING(10) REGREETING(10) REGRETTING(10) REIGNITE(8) REIGNITING(10)\n",
" REINTERRING(11) RENTING(7) RETINTING(9) RETIRING(8) RETTING(7) RINGENT(7) TEETERING(9) TENTERING(9)\n",
" TIERING(7) TITTERING(9) TREEING(7) TRIGGERING(10)\n",
" AEGNR 120 points 18 words ANGER(5) ARRANGE(7) ARRANGER(8) ENGAGER(7) ENRAGE(6) GANGER(6) GANGRENE(8)\n",
" GARNER(6) GENERA(6) GRANGE(6) GRANGER(7) GREENGAGE(9) NAGGER(6) RANGE(5) RANGER(6) REARRANGE(9)\n",
" REENGAGE(8) REGNA(5)\n",
" AEGRT 123 points 19 words AGGREGATE(9) ERGATE(6) ETAGERE(7) GARGET(6) GARRET(6) GARTER(6) GRATE(5) GRATER(6)\n",
" GREAT(5) GREATER(7) REAGGREGATE(11) REGATTA(7) REGRATE(7) RETAG(5) RETARGET(8) TAGGER(6) TARGE(5)\n",
" TARGET(6) TERGA(5)\n",
" AEINR 19 points 3 words INANER(6) NARINE(6) RAINIER(7)\n",
" AEIRT 135 points 20 words ARIETTA(7) ARIETTE(7) ARTIER(6) ATTIRE(6) ATTRITE(7) IRATE(5) IRATER(6)\n",
" IRRITATE(8) ITERATE(7) RATITE(6) RATTIER(7) REITERATE(9) RETIA(5) RETIARII(8) TARRIER(7) TATTIER(7)\n",
" TEARIER(7) TERAI(5) TERRARIA(8) TITRATE(7)\n",
" AENRT 132 points 19 words ANTEATER(8) ANTRE(5) ENTERA(6) ENTRANT(7) ENTREAT(7) ERRANT(6) NARRATE(7)\n",
" NARRATER(8) NATTER(6) NEATER(6) RANTER(6) RATTEEN(7) RATTEN(6) RATTENER(8) REENTRANT(9) RETREATANT(10)\n",
" TANNER(6) TERNATE(7) TERRANE(7)\n",
" AGINR 138 points 19 words AGRARIAN(8) AIRING(6) ANGARIA(7) ARRAIGN(7) ARRAIGNING(10) ARRANGING(9)\n",
" GARAGING(8) GARNI(5) GARRING(7) GNARRING(8) GRAIN(5) GRAINING(8) INGRAIN(7) INGRAINING(10) RAGGING(7)\n",
" RAGING(6) RAINING(7) RANGING(7) RARING(6)\n",
" AGIRT 5 points 1 word TRAGI(5)\n",
" AGNRT 5 points 1 word GRANT(5)\n",
" AINRT 64 points 9 words ANTIAIR(7) ANTIAR(6) ANTIARIN(8) INTRANT(7) IRRITANT(8) RIANT(5) TITRANT(7)\n",
" TRAIN(5) TRINITARIAN(11)\n",
" EGINR 186 points 24 words ENGINEER(8) ENGINEERING(11) ERRING(6) GINGER(6) GINGERING(9) GINNER(6) GINNIER(7)\n",
" GREEING(7) GREENIE(7) GREENIER(8) GREENING(8) GRINNER(7) NIGGER(6) REENGINEER(10) REENGINEERING(13)\n",
" REGREENING(10) REIGN(5) REIGNING(8) REINING(7) RENEGING(8) RENIG(5) RENIGGING(9) RERIGGING(9)\n",
" RINGER(6)\n",
" EGIRT 27 points 4 words GRITTIER(8) TERGITE(7) TIGER(5) TRIGGER(7)\n",
" EGNRT 12 points 2 words GERENT(6) REGENT(6)\n",
" EINRT 190 points 29 words ENTIRE(6) INERT(5) INTER(5) INTERN(6) INTERNE(7) INTERNEE(8) INTERTIE(8)\n",
" NETTIER(7) NITER(5) NITERIE(7) NITRE(5) NITRITE(7) NITTIER(7) REINTER(7) RENITENT(8) RENTIER(7)\n",
" RETINE(6) RETINENE(8) RETINITE(8) RETINT(6) TEENIER(7) TENTIER(7) TERRINE(7) TINIER(6) TINNER(6)\n",
" TINNIER(7) TINTER(6) TRIENE(6) TRINE(5)\n",
" GINRT 43 points 6 words GIRTING(7) GRITTING(8) RINGGIT(7) TIRING(6) TRIGGING(8) TRINING(7)\n",
" AEGR 84 points 17 words AGER(1) AGGER(5) AGREE(5) ARREARAGE(9) EAGER(5) EAGERER(7) EAGRE(5) EGGAR(5)\n",
" GAGER(5) GAGGER(6) GARAGE(6) GEAR(1) RAGE(1) RAGEE(5) RAGGEE(6) REGEAR(6) REGGAE(6)\n",
" AEIR 22 points 4 words AERIE(5) AERIER(6) AIRER(5) AIRIER(6)\n",
" AENR 40 points 9 words ANEAR(5) ARENA(5) EARN(1) EARNER(6) NEAR(1) NEARER(6) RANEE(5) REEARN(6) RERAN(5)\n",
" AERT 127 points 24 words AERATE(6) ARETE(5) EATER(5) ERRATA(6) RATE(1) RATER(5) RATTER(6) REATA(5)\n",
" RETEAR(6) RETREAT(7) RETREATER(9) TARE(1) TARRE(5) TARTER(6) TARTRATE(8) TATER(5) TATTER(6) TEAR(1)\n",
" TEARER(6) TERRA(5) TERRAE(6) TETRA(5) TREAT(5) TREATER(7)\n",
" AGIR 6 points 2 words AGRIA(5) RAGI(1)\n",
" AGNR 13 points 5 words GNAR(1) GNARR(5) GRAN(1) GRANA(5) RANG(1)\n",
" AGRT 13 points 3 words GRAT(1) RAGTAG(6) TAGRAG(6)\n",
" AINR 8 points 4 words AIRN(1) NAIRA(5) RAIN(1) RANI(1)\n",
" AIRT 21 points 5 words AIRT(1) ATRIA(5) RIATA(5) TIARA(5) TRAIT(5)\n",
" ANRT 50 points 10 words ANTRA(5) ARRANT(6) RANT(1) RATAN(5) RATTAN(6) TANTARA(7) TANTRA(6) TARN(1)\n",
" TARTAN(6) TARTANA(7)\n",
" EGIR 17 points 3 words GREIGE(6) RERIG(5) RIGGER(6)\n",
" EGNR 37 points 6 words GENRE(5) GREEN(5) GREENER(7) REGREEN(7) RENEGE(6) RENEGER(7)\n",
" EGRT 45 points 7 words EGRET(5) GETTER(6) GREET(5) GREETER(7) REGREET(7) REGRET(6) REGRETTER(9)\n",
" EINR 17 points 4 words INNER(5) REIN(1) RENIN(5) RENNIN(6)\n",
" EIRT 87 points 17 words RETIE(5) RETIRE(6) RETIREE(7) RETIRER(7) RITE(1) RITTER(6) TERRIER(7) TERRIT(6)\n",
" TIER(1) TIRE(1) TITER(5) TITRE(5) TITTER(6) TITTERER(8) TRIER(5) TRITE(5) TRITER(6)\n",
" ENRT 104 points 19 words ENTER(5) ENTERER(7) ENTREE(6) ETERNE(6) NETTER(6) REENTER(7) RENNET(6) RENT(1)\n",
" RENTE(5) RENTER(6) RETENE(6) TEENER(6) TENNER(6) TENTER(6) TERN(1) TERNE(5) TERREEN(7) TERRENE(7)\n",
" TREEN(5)\n",
" GINR 44 points 9 words GIRN(1) GIRNING(7) GRIN(1) GRINNING(8) IRING(5) RIGGING(7) RING(1) RINGING(7)\n",
" RINNING(7)\n",
" GIRT 3 points 3 words GIRT(1) GRIT(1) TRIG(1)\n",
" AER 25 points 7 words AREA(1) AREAE(5) ARREAR(6) RARE(1) RARER(5) REAR(1) REARER(6)\n",
" AGR 2 points 2 words AGAR(1) RAGA(1)\n",
" AIR 2 points 2 words ARIA(1) RAIA(1)\n",
" ART 24 points 5 words ATTAR(5) RATATAT(7) TART(1) TARTAR(6) TATAR(5)\n",
" EGR 15 points 4 words EGER(1) EGGER(5) GREE(1) GREEGREE(8)\n",
" EIR 11 points 2 words EERIE(5) EERIER(6)\n",
" ENR 1 point 1 word ERNE(1)\n",
" ERT 27 points 7 words RETE(1) TEETER(6) TERETE(6) TERRET(6) TETTER(6) TREE(1) TRET(1)\n",
" GIR 7 points 2 words GRIG(1) GRIGRI(6)\n"
]
}
],
"source": [
"report()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Step 10: What honeycombs have a high score without a lot of words?\n",
"\n",
"[Michael Braverman](https://www.linkedin.com/in/michael-braverman-2b32721/) said he dislikes puzzles with a lot of low-scoring four-letter words. Can we find succint puzzles with lots of points and fewer words? With two objectives there won't be a single best answer to this question; rather we can ask: what honeycombs are there such that there are no other honeycombs with both more points and fewer words? We say such honeycombs are [**Pareto optimal**](https://en.wikipedia.org/wiki/Pareto_efficiency) and are on the **Pareto frontier**. We can find them as follows:"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {},
"outputs": [],
"source": [
"def pareto_honeycombs(words) -> list: \n",
" \"\"\"A table of {word_count: (points, honeycomb)} with highest scoring honeycomb.\"\"\"\n",
" points_table = tabulate_points(words)\n",
" wcount_table = Counter(map(letterset, words))\n",
" honeycombs = (Honeycomb(letters, center) \n",
" for letters in points_table if len(letters) == 7 \n",
" for center in letters)\n",
" # Build a table of {word_count: (points, honeycomb)}\n",
" table = defaultdict(lambda: (0, None)) \n",
" for h in honeycombs:\n",
" points = game_score2(h, points_table)\n",
" wcount = game_score2(h, wcount_table)\n",
" table[wcount] = max(table[wcount], (points, h))\n",
" return pareto_frontier(table)\n",
" \n",
"def pareto_frontier(table) -> list:\n",
" \"\"\"The pareto frontier that minimizes word counts while maximizing points.\n",
" Returns a list of (wcount, points, honeycomb, points/wcount) entries\n",
" such that there is no other entry that has fewer words and more points.\"\"\"\n",
" return sorted((w, p, h, round(p/w, 2))\n",
" for w, (p, h) in table.items()\n",
" if not any(h2 != h and w2 <= w and p2 >= p\n",
" for w2, (p2, h2) in table.items()))"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"108"
]
},
"execution_count": 45,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"ph = pareto_honeycombs(enable1)\n",
"len(ph)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"So there are 108 (out of 55,902) honeycombs on the Pareto frontier. Let's see what the frontier looks like by plotting word counts versus points scored:"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"\n",
"