Pokemon Gen 1 Phonetic Pangram

posted by graham on December 28, 2025

As I mentioned in my previous post, a phonetic pangram is a sentence or phrase that covers every one of the sounds in a given dialect of a language. Since proper nouns can form a phrase, a phonetic pangram could potentially be made from any sufficiently large collection of names.

This led me to the question: “Is it possible to make a phonetic pangram from pokemon names?” and more specifically, “Can we do so using only the 151 from the first generation of pokemon?”

Phonetics

For General American English, wikipedia lists the following sounds that comprise every commonly spoken word:

Consonants (24¹)

m, n, ŋ, p, b, t, d, k, ɡ, tʃ, dʒ, f, v, θ, ð, s, z, ʃ, ʒ, h, l, r, j, w

Vowels (14)

ɪ, i, ʊ, u, ɛ, eɪ, ə, oʊ, æ, ɑ, aɪ, ɔɪ, aʊ, ɚ

To make a pangram, I simply needed pokemon names that encompassed each of these 38 phonemes. You could imagine a worst case of 38, where each pokemon is picked for having exactly on phoneme represented in its name, though I figured there was probably more overlap than that.

Pokemon name pronunciations

I was able to find the pronunciations of all 151 gen 1 pokemon. I copied the table and kept only the name and IPA pronunciation columns. A given pokemon name contains many phonemes:

ekans ɛkənz

First, I had to figure out whether the set of these pokemon match the 48 phonemes labeled above. To do this, I iterated over every row and added the phonemes for that pokemon’s pronunciation to an ever-growing set. Once I reached the end, I found that there were more than 48 phonemes represented, which meant I needed to do some data cleanup.

Data Cleanup

There are four different kinds of cleanup that were necessary for this dataset:

1. Two-character phonemes: for diphthongs and dual-character phonemes like dʒ, I needed to replace these combos with single-character variants instead.
2. Americanized phonemes: because of the cot/caught merger and the hurry/furry merger, among others, it was necessary to map all present phonemes that other dialects used onto General American English.
3. Incorrect phonemes: There were a couple of places like Victreebel where phones like /r/² which seemed like a mistake, to my ears.
4. Ambiguous phonemes: In the case of Nidoran♂ and Nidoran♀, it is unclear whether the names are supposed to include “male” and “female” in the pronunciations. Even canonical anime pronunciations differ depending on episode.³ For the purposes of this challenge, it seemed best to omit them.

After cleanup, I continued to work on the problem.

Set Cover

I got an old familiar feeling while doing this problem. I thought maybe it was from a previous advent of code or something. I couldn’t remember what the problem I was thinking of was formally called — only previous times that I had encountered it.

In designing levels for Snails and Sorcery⁴, I mapped out every single mechanic for every single level into a big spreadsheet so that I could tell at a glance whether a given level was introducing too many mechanics at once. Later, I wanted to see which levels would make the smallest set while representing every mechanic.

Another place this has come up is in Magic: the Gathering combos. There’s a silver-bordered⁵ card that lets you win the game if you make a pangram with card names.

Trying to find the smallest combo of card names to achieve this pangram is the same problem, just put in a slightly different context.

When I asked around, my friends told me that this was a classic Set Cover problem and that it’s a notoriously difficult problem once the problem size grows big enough.

Here I was, once again wondering if there was some collection of things (i.e. pokemon names) that would cover all of a set (i.e. General American English phonemes). Thankfully this problem has the benefit that the set of all pokemon (especially just gen 1) is plenty small compared to the set of all MTG cards and is also very small compared to the limit where solving this problem would take too long to complete.

A greedy approximation

Generally with Set Cover, it’s a lot easier to get a solution that’s pretty good than a solution that’s provably the best. Instead of worrying about the best next step, a heuristic like “start by adding the item which has the fewest overlaps with other items” can get close enough. In this case, that’d be a pokemon whose names contain a phoneme or phonemes that are shared least by the other pokemons’ names in the set.

Persian pɝʒən

Persian is the only gen one pokemon with the ʒ sound. This means that Persian must be included in every gen 1 phonetic pangram. It also means that p,ɝ,ə, and n get covered automatically.

For all other “least common remaining phonemes”, there would be more than one pokemon which contained that phoneme in its name. For instance:

Vulpix vʊlpɪks, Bulbasaur bʊlbəsɑɹ

Blastoise blæstɔɪs, Cloyster klɔɪstɚ

Which of the pokemon names in these pairs is better to add? Is it better to add a pokemon from the first pair or the second one? For this greedy approximation, I went with “the one from the first-looked-at-phoneme that will cause the most phonemes to be added to the covering set, or go with the last pokemon if there’s a tie.” In this case, that’s Bulbasaur because b ʊ l ə s ɑ ɹ is seven more phonemes covered, as compared with v ʊ l ɪ k s the six from Vulpix when you account for p already being covered by Persian. From here it’s possible to continue and get an answer, but remember that that’s still a heuristic (good enough) approximation rather than a provably best answer.

From here, there was a bunch of trial and error to discover and fix the points mentioned in the data cleanup. Originally, the next to choose from was Nidoran♀ because it contained an empty space ⁶. Next, every answer included Victreebel because it was the only one containing /r/. Then, every answer contained Omanyte or Arcanine because they contained ɑɪ instead of aɪ. This continued for a while.

After working through cleaning up all of these edge cases, there was finally a reasonable approximate answer:

Persian 
Bulbasaur
Blastoise
Meowth
Sandshrew
Hypno
Exeggcute
Koffing
Squirtle
Ivysaur
Charmander
Pidgey

These 12 pokemon names looked to form a nice phonetic pangram. But could the same be achieved with 11? 10?

Minmaxing with Recursion™

I noticed while writing the greedy heuristic algorithm that one aspect (number of pokemon names which contain this next phoneme)was minimized while another aspect (the number of phonemes that would get added to the covering set) was maximized. By thinking of these steps as a two-player game, it’s possible to reframe this problem as a version of Minimax. Similar to how humans and computers “think ahead” a number of moves in a game like chess, perhaps the best move (pokemon to choose) at a given step could be dependent on thinking X-many moves ahead?

I wrote a recursive algorithm in Typescript for solving this problem. If there were no phonemes that still needed to be added to the set, then the program could stop and return the solution. A given solution could be rated by its number of pokemon names. The best solution would be one that minimized the number of pokemon, which could be filtered for after exploring all of the possible solutions.

Searching without Recursion™

Javascript, which Typescript runs under the hood, has a max number of times that a recursive function can call itself (i.e. “max depth”) of 10 times. I immediately ran into this limit. I should have known better when I selected this language for writing the algorithm in the first place, but I forgot. There are ways around the max depth restriction, but I find it’s always good practice for code maintainability to unwind the recursion. Generally recursion asks the person reading the code to maintain the state of the program in their head, whereas other approaches can make that state much clearer and easier to inspect when things go wrong.

I rewrote the algorithm to be more like searching an N-dimensional grid, where each pokemon chosen was like a new direction through a maze, and the set of pokemon names at the end was like the path taken to get to the finish. The goal was to minimize the path length, and at each step along the way, I kept track of “the path so far” for every possible “next step to take”. As I got to a branching point in the maze, I just added each of the “potential next steps to take” to a list. When the list was empty, I knew that all possible paths had been exhausted.

This time, when I ran the program, it didn’t immediately error out. In fact, it didn’t do much of anything for a very long time, and I got bored.

Speeding up the search with pruning

Given that the greedy heuristic solution found a way through the “maze” in 12 steps, I knew that I could get rid of any potential next step that would be greater than or equal to 12 steps long. This is sort of like a simple version of alpha-beta pruning, in that I was pruning out solutions that were known to be worse than the greedy approximation solution of 12. This optimization may have helped, but not enough for me to notice.

Next, I tried to keep the list ordered by how long the path had been so far. This helped avoid looking at bad solutions before good ones, but I found that the program still took a very long time.

When I looked at what was happening step by step towards the beginning of the search, I noticed that there were ways for the same list of pokemon to show up in a solution, just in a different order. Going back to the greedy algorithm example from before:

Vulpix vʊlpɪks, Bulbasaur bʊlbəsɑɹ

Blastoise blæstɔɪs, Cloyster klɔɪstɚ

In exploring each of these possibilities, there would be one that would look like Persian, Vulpix, Blastoise and another that would look like Persian, Blastoise, Vulpix. These two states are equivalent in terms of how much they cover the set of phonemes, but the paths to get to each were different-looking enough that my code was treating them as independent solutions.

I decided to make an in-memory cache that would tell me whether I had “been to this part of the maze” before. All I had to do was name each spot in the maze in a way that would give the same name every time I asked for the same spot. For instance, the first spot in the maze could be called Persian since the algorithm only had one choice. Then when I added new names, I could sort them all alphabetically, and then join them together into a single name like Persian|Vulpix or Blastoise|Persian|Vulpix. By storing each place name I had already been, I could avoid accidentally back-tracking through parts of the maze. This greatly sped up how long the search took to solve.

The final results

After running and re-running to find the best solutions, these were the solutions I found. Note that Persian, Blastoise, and Vulpix are in all of them:

Persian
Blastoise
Vulpix
Growlithe
Shellder
Hitmonchan
Ninetales
Cubone
Jigglypuff
Weezing

Persian
Blastoise
Vulpix
Growlithe
Shellder
Hitmonchan
Ninetales
Cubone
Jynx
Wigglytuff

Persian
Blastoise
Vulpix
Growlithe
Shellder
Hitmonchan
Primeape
Cubone
Jigglypuff
Weezing

Persian
Blastoise
Vulpix
Growlithe
Shellder
Rhyhorn
Clefable
Charmeleon
Geodude
Weezing

Persian
Blastoise
Vulpix
Growlithe
Oddish
Clefable
Rhyhorn
Charmeleon
Geodude
Weezing

Persian
Blastoise
Vulpix
Growlithe
Sandshrew
Rhyhorn
Clefable
Charmeleon
Geodude
Weezing

Persian
Blastoise
Vulpix
Growlithe
Sandshrew
Rhyhorn
Clefable
Charmeleon
Pidgeotto
Weezing

Persian
Blastoise
Vulpix
Growlithe
Rapidash
Rhyhorn
Clefable
Charmeleon
Geodude
Weezing

Persian
Blastoise
Vulpix
Growlithe
Sandslash
Rhyhorn
Clefable
Charmeleon
Geodude
Weezing

Persian
Blastoise
Vulpix
Meowth
Shellder
Hitmonchan
Primeape
Cubone
Jigglypuff
Weezing

Conclusion

While writing this post, I had to go back through and double check everything. After all, who would ever want to be wrong on the internet?

I took one of the sets of phonemes from these final results and checked each phoneme against the list at the beginning. There was one missing. Apparently, throughout my process cleaning, running, readjusting, etc I had thought that there were 38 phonemes present, but it was just an errant ˌ in /ˌpɪdʒiːˈoʊɾoʊ/ and a few others that had caused the number to look right when it wasn’t. Upon cleaning that final non-phoneme up, my solutions all read 37. The missing phoneme throughout all of this has been ð.

Sure, there’s some sunk cost aspect to have written all of this only to have the answers to:

“Is it possible to make a phonetic pangram from pokemon names?” and more specifically, “Can we do so using only the 151 from the first generation of pokemon?”

be “no.” I double-checked that I hadn’t missed any pronunciations. Was Growlithe maybe actually pronounced like “tithe”? No, it definitely used θ in the pronunciation guide.

Ok, so the above solutions are sufficient for 37/38 phonemes, which seems like as good as could be done for gen 1. What generation of pokemon does ð first show up in? According to the same dataset I got these gen 1 pronunciations from, it wasn’t until Gen IX that there finally was a pokemon whose english pronunciation contained ð. It was Slither Wing. The only other pokemon to ever have ithe in its name was Growlithe.

To get a phonetic pangram with pokemon, it’s possible to add Slither Wing to any of the above solutions and have 11 names cover it. I’ll postpone looking into phonetic pangrams across all gens for a future post.

As for gen 1 specifically, maybe I’ll try to start saying Growlithe with a ð from now on, and say it’s 11 pokemon for gen 1 to make a phonetic pangram. You might say “but if Growlithe uses ð, then how will you get the θ you previously used it to cover?” and I would reply simply:

Meowth /miːˈaʊθ/, that’s right.