Word search phone numbers

Using This Solver

Trying to find a memorable phone number? This phone number word finder finds words you can spell with your phone number. These words are often called phonewords and are much easier for people to remember and share with their friends. You can use this tool to help select a custom phone number (aka vanity phone number) for your business or find possible ways to refer the phone number you already have.

The results are ranked by a quality score, which places the best words first(usually the longest words with the best position within the phone number); tab through the results to see the rest of the words.

You can also use this tool to help solve puzzles based on phonepad letters. We’ve seen
a couple of these; some of these will appear as simple number sequences. More advanced ones take advantage of the fact the phone pad is a 3 x 4 grid and share the progression
between the spots on the grid vs. the actual number itself.

How This Solver Works

This is a phonetic alphabet solver, used to help you find a words that can be made using a phone keypad (phone word). These are easier to remember than phone numbers and can be used to create interesting mnemonics. This is helpful if you’re trying to pick business phone numbers (part of your company name) or a vanity number (for your cell number or cell phone app). This can increase your phone call volume by helping you make odd combinations memorable (so a caller remembers your business); it looks at generic words you can link into the number, along with the remaining letters.

To use the phone word solver , simply enter the telephone number (including area code for calls) and it will examine your options. This phone word solver uses the nato phonetic alphabet using a standard telephone keypad (device). It supports local number, toll free number and country code patterns as well. (Although it may find a reduced number of possible word combinations as it runs the process to convert phone number to words). You will need to check with the phone company if this is an existing phone number. There are third party providers who can help you with this as well. Special rules limit mobile number in various countries (mobile phone number policies); check for available number and existing number limits. You can also include an extra digit for certain systems (your smartphone or iphone may not handle this consistently; standards vary).

This website is powered by a flexible dictionary search engine (that powers our scrabble helper. This dictionary search takes a sequence of letters and iterates through the possible words which you can form with those letters by swapping them around. So given a letter series EPHON, it looks at all of the possible ways to rearrange the letters into sequences which match actual words yielding PHONE. It accomplishes this in under a second, on the server side — it may take slightly longer for the data to move back & forth via the internet.

The phone number word search is a modified version of this dictionary search engine; every letter in the sequence maps to several possible values (eg. 1 => A, B, C). We iterate through each digit in the number, constructing a word out of each of the possible options for each number in sequence using the phone pad letters. These possible words are compared with the dictionary to eliminate fruitless paths (eg. once we’re comfortable the first three letters in a possible phone number word cannot be used to spell anything, we stop searching for sequences that include part of the stream).

Unlike the scrabble solver search, the engine has been set to tolerate a little bit of junk letters / numbers in the word. In the real world, many successful phonewords have blended short words (3 — 4 letters) with additional digits before or after the word. So once we see «a legitimate word» in one of the possible paths, we will usually keep the resulting options.

Which brings us to the «quality function» used to rank results. Most real world users have a preference for longer words or word pairs, which will consume most of the phone number. There is also a preference for phone words where the additional digits have been placed in an obvious and easily remembered spot, such as the middle three digits or the last four digits (such as 555-SORT or EAT-1234). After we generate a (usually large) list of possible phone words, we have a ranking function that sorts these into order based on their expected desirability.

May 17th, 2007

Hey, MN. You know, many years ago the Scripting Guy who writes this column read The Hitchhiker’s Guide to the Galaxy. Now, being a Scripting Guy, he can’t help but admire anyone who writes a trilogy that actually contains five books. However, he still feels obligated to point out that the Hitchhiker’s Guide informed everyone that the answer to the ultimate question of life, the universe, and everything (a question that hasn’t even been asked yet) is 42. Sorry, but that’s simply not right. Instead, the correct answer is 1301.

Why 1301? Well, we’re assuming that the ultimate question of life, the universe, and everything is this: if I go to TechEd 2007 in Orlando, how in the world will I ever track down the Scripting Guys? The answer? By remembering the magic number: 42.

Oh, wait; sorry. The magic number is 1301, not 42. Go into the Partners Expo and look for booth 1301, the CMP Media booth. See the guy in a ratty old black hat with the word Japan on it and the woman with a bunch of staples in her head? Well, there you go: you just found the Scripting Guys. We’re interested in talking to as many people as we can (or, to be more accurate, as many people as we can before we can slip out the back door and head for Splash Mountain.) So if you find yourself in Orlando June 4-8 be sure to drop by and say hi, and to give us an idea of what we can do to serve you better.

Remember that number: 1301. The same year that Scripting Guy Peter Costantini was born.

Now that we know the answer to the ultimate question of life it’s time to turn our attention to the next ultimate question of life: how can I extract phone numbers from a text file? According to MN’s email she has a series of text files, each of them looking something like this:

Ken Myer
Accountant
Fabrikam, North American Division
Building 16, Room 129
Redmond, WA 98052
425-555-1212 (office), 425-555-5656 (cell)
Wife’s name: Sarah
Children: Robert (4), Teri (2)
425-555-3434 (home)

What MN needs to do is read through these files and extract the phone numbers, like so:

425-555-1212 (office)
425-555-5656 (cell)
425-555-3434 (home)

That doesn’t sound too hard, does it? Unfortunately though, there’s at least one complication: the text files are not necessarily consistent. For example, in Ken Myer’s text file his home phone appears on line 9. However, suppose Ken wasn’t married and suppose he didn’t have any children. In that case, his text file would look like this, and his home phone would appear on line 7:

Ken Myer
Accountant
Fabrikam, North American Division
Building 16, Room 129
Redmond, WA 98052
425-555-1212 (office), 425-555-5656 (cell)
425-555-3434 (home)

Likewise, while the phone numbers will always be in the same format: Area Code-Prefix-Suffix (phone type), the area codes can (and will) differ, as will the phone types. For example, some people don’t have cell phones. In other words, about all we can do is search for a particular pattern and then report back each instance of that pattern. But how in the world can we do that?

Well, here’s one way:

Const ForReading = 1
Set objFSO = CreateObject(“Scripting.FileSystemObject”)
Set objFile = objFSO.OpenTextFile(“C:ScriptsKen_myer.txt”, ForReading)
strSearchString = objFile.ReadAll
objFile.Close
Set objRegEx = CreateObject(“VBScript.RegExp”)
objRegEx.Global = True   
objRegEx.Pattern = “d{3}-d{3}-d{4} ([a-zA-Z]*)”
Set colMatches = objRegEx.Execute(strSearchString)  
If colMatches.Count > 0 Then
   For Each strMatch in colMatches   
       Wscript.Echo strMatch.Value 
   Next
End If

Before we begin explaining how this script works, take a deep breath and relax: this is nowhere near as complicated as it might look. As you can see, we actually start off in very simple fashion, defining a constant named ForReading and setting the value to 1. (We’ll need this constant when we go to open the text file). Speaking of which, our next two steps are to create an instance of the Scripting.FileSystemObject object and then use the OpenTextFile method to open the file C:ScriptsKen_myer.txt:

Set objFSO = CreateObject(“Scripting.FileSystemObject”)
Set objFile = objFSO.OpenTextFile(“C:ScriptsKen_myer.txt”, ForReading)

As soon as the file is open we use the ReadAll method to read in the entire file and store the contents in a variable named strSearchString. And once we have the contents stashed safely away in strSearchString we go ahead and close the text file.

Now comes the tricky part.

If we were searching for a particular value (e.g., the phone number 425-555-1212) we could simply use VBScript’s InStr function. However, we aren’t interested in any one phone number; as we noted before, we’re really look for a phone number pattern. Any time you’re searching for a pattern you need to use a regular expression. That’s also true for the Scripting Guys: any time we’re searching for a pattern we need to use a regular expression. Hence the next line of code, which creates an instance of the VBScript.RegExp object:

Set objRegEx = CreateObject(“VBScript.RegExp”)

Once we have a regular expression object we need to configure two key properties of that object. First, we set the Global property to True; this tells the regular expression object that we want to search the entire target string (strSearchString) for all instances of the pattern. If Global is set to False then the regular expression object will find the first instance of the pattern and then stop. In this case, that’s no good: it would find the first phone number and then quit, without looking for any additional phone numbers for Ken Myer.

And then it’s time to define our search Pattern:

objRegEx.Pattern = “d{3}-d{3}-d{4} ([a-zA-Z]*)”

Maybe you better sit down; you look a little dizzy. That’s the problem with regular expressions: you take one look at the syntax and your first thought is to panic. Listen, don’t panic (as the Hitchhiker’s Guide repeatedly implored). Regular expression syntax isn’t very pretty, but it can be explained.

To begin with, our phone numbers always start with the area code; that means a phone number will always start with three numbers back-to-back-to-back. Because of that, our regular expression also starts with three numbers; that’s what the d{3} is for. (The d means digits, the {3} means there must be three consecutive digits.) After the area code we have a hyphen followed by three more digits (the prefix). And guess what? In our regular expression we also have a hyphen followed by three more digits (again using d{3}). In the phone number the prefix is followed by another hyphen and four more digits. And in our regular expression – that’s right, we have the exact same thing: d{4}. (Note that we use the syntax {4} because we’re now looking for four consecutive digits.)

That’s actually all the information we need to find phone numbers. However, each phone number of followed by a parenthetical statement that tells us the type of phone number (e.g., (cell)). We thought it might be nice to grab these parenthetical statements as well. Therefore, we decided to gussy up our pattern a little bit.

So how did we gussy up our pattern? Well, if you look closely you’ll see there’s a blank space immediately following the telephone suffix; that corresponds to the blank space in a phone number like 425-555-1212 (office). Following the blank space we use this construction to represent the opening parenthesis: (. (Why the before the parenthesis? That’s because the open and close parentheses are reserved characters in regular expressions. The simply tells the script to look for the actual open parenthesis character; that is, look for the ( character.)

You might note that, at the end of the pattern, we use a similar construction to represent the close parenthesis: ).

OK, so open and close parentheses aren’t too hard. But what about the stuff that goes between the parentheses? At the very least that could be office, cell, or home; how do we search for something that could be almost anything?

To be honest, there are probably all sorts of ways to do that. (Regular expressions are nothing it not flexible.) Because everything within the parentheses is going to be a word (of some kind) we decided to go this route:

[a-zA-Z]*

We’ve actually got several things going on here. To begin with, we’re interested only in letters, either lowercase or uppercase. In a regular expression, you can search for a range of values by enclosing that range within square brackets and by using hyphens as needed. Inside our square brackets we actually have two items: a-z and A-Z. The a-z syntax simply says, “Find anything that begins with a lowercase letter (a-z)”; as you might expect, the A-Z syntax says “Find anything that begins with an uppercase letter (A-Z).” The net effect is that we’re searching for any letter (lowercase or uppercase). If there’s a number or a punctuation mark or anything but the letters A through Z then this won’t be considered a match.

OK, so we’re searching for letters (and only letters) enclosed in parentheses. But how many letters are we searching for? Well, we don’t know. The word office has 5 letters; the word cell has 4. Technically, we’re looking for 0 or more letters; that’s what the asterisk (*) represents. In other words, we’re looking for a phone number, followed by a blank space, followed by a parenthetical statement that contains 0 or more letters (and only letters).

Confused? We don’t blame you. Truthfully, the best way to understand how regular expressions work is to play with them a bit. For example, try removing the a-z section from the pattern and then running the script. The script won’t find any phone numbers. Why not? Because, with a-z removed, all that’s left is A-Z, meaning that we’re looking only for uppercase letters (e.g., OFFICE). Now, go into the text file, make everything uppercase, and try the script again.

Speaking of trying the script, here’s what we get back when we try the script:

425-555-1212 (office)
425-555-5656 (cell)
425-555-3434 (home)

Which is exactly what we wanted to get back.

OK, so now we know how to locate phone numbers in a text file. That’s good, but it doesn’t fully answer MN’s question; after all, she asks how to perform this task on scores of text files. That’s a good question, and it’s one we get asked quite a bit: how do I perform the same task on a whole bunch of text files, all at the same time. That’s something we’ll address tomorrow, as the conclusion to a rare two-part Hey, Scripting Guy! column.

In conclusion, remember, that’s booth 1301 (the CMP Media booth) in the Partners Expo hall. The Scripting Guys will be there, they’ll have a fun little giveaway for everyone, and you’ll have the opportunity to win your very own Dr. Scripto bobblehead doll.

Actually we should clarify that a bit: Scripting Guy Greg Stemp will be there in booth 1301. However, if her trip to Florida goes anything like her trip to San Diego you’ll need to go to the Orlando Regional Medical Center if you want to talk to Scripting Guy Jean Ross. But be sure and drop by there and say hi. (And maybe give her a pint of blood or something while you’re there.) Editor’s Note: Scripting Guy Jean Ross had the staples removed weeks ago, is perfectly healthy, and will be in booth 1301. Or so she insists.

^#^#^#-^#^#^#-^#^#^#^#

4

The key here would be to acquire all the different character combinations that can derive from the characters related to the supplied number in the left to right sequence of that number. Obviously the larger the supplied number, the more combinations there will be. The number of 26678837 which you provided in your post for example can generate 11,664 unique character combinations (string words).

 2     6     6     7     8     8     3     7
abc   mno   mno   pqrs  tuv   tuv   def   pqrs

Each one of these 11,664 generated string words would need to be passed through a dictionary of sorts which in itself may contain let’s say 170,000 (or more) words and checked for (case insensitive) equality. This is not going to be an overly quick process since that equates to almost 2 billion inspections for equality. This takes about 1 minute, 20 seconds on my 10 year old desktop Windows box.

In any case the method provided below takes the supplied string number, generates the different character combinations (character words) and compares each one against the words within the supplied dictionary (word) text file. Read the doc’s that are attached to the method:

/**
 * Converts the supplied string telephone number (or any string of integer 
 * numbers) to possible words acquired from within the supplied dictionary 
 * text file.<br><br>
 * 
 * Specific digits relate to specific alpha characters as they do in a telephone
 * keypad, for example:<pre>
 * 
 *      1    2    3    4    5    6    7    8    9    0
 *          ABC  DEF  GHI  JKL  MNO  PQRS TUV  WXYZ
 * </pre>
 * 
 * Digits 1 and 0 do not relate to any alpha characters. By looking at the 
 * above scale you can see how a number like "26678837" can generate 11,664 
 * unique character combinations (string words). Each one of these combinations 
 * needs to be check against the supplied dictionary (or word) text file to see
 * if matches a specific dictionary word. If it does then we store that word 
 * and carry on to the next character combination. If the dictionary (word) 
 * text file contains 170,000 words and there are 11,664 different character 
 * combinations then a simple calculation (170,000 x 11,664) determines that 
 * there will need to be 1,982,880,000 (almost 2 billion) inspections done for 
 * equality. Because of this, many (sometimes thousands) of Executor Service 
 * threads are used to speed up the processing task. At the end of the day 
 * however, task speed completely relies on the speed of the Hard Disk Drive 
 * (HDD) and too many threads can actually degrade performance. It's a tough 
 * balance. Modify things as you see fit.
 * 
 * 
 * 
 * @param dictionaryFilePath (String) The path and file name of the dictionary 
 * file to gather possible words from. This dictionary (or word) file must 
 * contain a single word on each line of the file. There can not be more than 
 * one word on any given file line. Blank lines within the file are ignored. 
 * Letter case is always ignored during processing however any words found and 
 * returned will be in Upper Letter Case.<br><br>
 * 
 * If you don't currently have a dictionary or word text file available then 
 * you can easily acquire one from the Internet.<br>
 * 
 * @param telephoneNumber (String) The telephone number (or any number) to 
 * convert to a dictionary word. Any non-digit characters within the supplied 
 * string are automatically removed so that only digits remain. The longer 
 * the number string, the longer it takes to process this number to a word. 
 * There is no guarantee that the number you supply will produce a word from 
 * within the supplied dictionary (word) file.<br>
 * 
 * @param showProcess (boolean) If boolean 'true' is supplied then the processing 
 * is displayed within the console window. This however slows things down 
 * considerably but does give you an idea what is going on. Because larger 
 * string numbers can take some time to complete processing, a modal 'Please 
 * Wait' dialog with a progress bar is displayed in the middle of your screen. 
 * When processing has completed this dialog window is automatically closed.<br>
 * 
 * @return (String[] Array) A String[] Array of the word or words from the 
 * supplied dictionary (word) file which the supplied number correlates to. 
 */
public static String[] telephoneNumberToDictionaryWords(final String dictionaryFilePath, 
                       final String telephoneNumber, final boolean showProcess) {
    long timeStart = System.currentTimeMillis();
    if (dictionaryFilePath == null || dictionaryFilePath.isEmpty()) {
        System.err.println("The argument for dictionaryFilePath can not be null or empty!");
        return null;
    }
    else if (telephoneNumber == null || telephoneNumber.trim().isEmpty()) {
        System.err.println("The argument for telephoneNumber can not be null or empty!");
        return null;
    }
    else if (!new File(dictionaryFilePath).exists()) {
        System.err.println("File Not Found! ("
                + new File(dictionaryFilePath).getAbsolutePath() + ")");
        return null;
    }
    String digits = String.valueOf(telephoneNumber).replaceAll("[^\d]", "");
    if (digits.isEmpty()) {
        return null;
    }
    List<String> foundList = new ArrayList<>();
    
    // ================== The 'Please Wait' Dialog Window ==================
    // Depending on the number supplied, this process can take a while to 
    // complete therefore put a popup 'Please Wait...' window into play 
    // here.
    final javax.swing.JFrame iframe = new javax.swing.JFrame();
    iframe.setAlwaysOnTop(true);
    iframe.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
    iframe.setLocationRelativeTo(null);
    
    final JDialog workingDialog = new JDialog(iframe);
    workingDialog.setCursor(java.awt.Cursor.getPredefinedCursor(java.awt.Cursor.WAIT_CURSOR));
    final JPanel p1 = new JPanel(new BorderLayout());
    javax.swing.border.Border lineBorder = javax.swing.BorderFactory.createLineBorder(Color.red, 4);
    p1.setBorder(lineBorder);
    p1.setBackground(Color.BLACK);
    p1.setPreferredSize(new java.awt.Dimension(255, 150));
    
    final JLabel label = new JLabel();
    label.setHorizontalAlignment(JLabel.CENTER);
    label.setVerticalAlignment(JLabel.CENTER);
    label.setText("<html><font size='5',color=#14e5eb><b><center>Please Wait..."
                  + "</center></b></font><br><center>This can take a little "
                  + "while.</center></html>");
    label.setForeground(Color.WHITE);
    p1.add(label, BorderLayout.CENTER);
    
    final JLabel label2 = new JLabel();
    label2.setHorizontalAlignment(JLabel.CENTER);
    label2.setVerticalAlignment(JLabel.CENTER);
    label2.setText("Hello World");
    label2.setForeground(Color.WHITE);
    p1.add(label2, BorderLayout.BEFORE_FIRST_LINE);
           
    final javax.swing.JProgressBar progressBar = new javax.swing.JProgressBar();
    progressBar.setPreferredSize( new java.awt.Dimension (190, 25));
    progressBar.setMaximumSize(new java.awt.Dimension(190,25));
    progressBar.setStringPainted(true);
    p1.add(progressBar, BorderLayout.SOUTH);
    
    workingDialog.setUndecorated(true);
    workingDialog.getContentPane().add(p1);
    workingDialog.pack();
    workingDialog.setLocationRelativeTo(iframe);
    workingDialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
    workingDialog.setModal(true);
    // =====================================================================

    SwingWorker<String, Void> worker = new SwingWorker<String, Void>() {
        @Override
        protected String doInBackground() throws InterruptedException {
            // Get the number of words contained within the supplied dictionary file.
            long numberOfDictionaryWords = 0L;
            // This will auto-close the stream.
            try (java.util.stream.Stream<String> linesStream
                    = java.nio.file.Files.lines(java.nio.file.Paths.get(dictionaryFilePath))) {
                numberOfDictionaryWords = linesStream.count();
            }
            catch (IOException ex) {
                System.err.println(ex);
            }
            if (showProcess) {
                System.out.println("The number of words in dictionary: --> " 
                                  + numberOfDictionaryWords);
            }

            // Map the alpha characters related to telephone digits
            HashMap<Character, String> map = new HashMap<>();
            map.put('0', "");
            map.put('1', "");
            map.put('2', "abc");
            map.put('3', "def");
            map.put('4', "ghi");
            map.put('5', "jkl");
            map.put('6', "mno");
            map.put('7', "pqrs");
            map.put('8', "tuv");
            map.put('9', "wxyz");

            // Get all the character combinations available for the
            // telelphone number (or just number) digits provided.
            List<String> phoneCharactersList = new ArrayList<>();
            phoneCharactersList.add("");
            for (int i = 0; i < digits.length(); i++) {
                if (digits.charAt(i) == '0' || digits.charAt(i) == '1') {
                    continue;
                }
                ArrayList<String> tempList = new ArrayList<>();

                String option = map.get(digits.charAt(i));

                for (int j = 0; j < phoneCharactersList.size(); j++) {
                    for (int p = 0; p < option.length(); p++) {
                        tempList.add(new StringBuilder(phoneCharactersList.get(j))
                                .append(option.charAt(p)).toString());
                    }
                }
                phoneCharactersList.clear();
                phoneCharactersList.addAll(tempList);
            }
            if (showProcess) {
                System.out.println("The number of generated words to process: --> "
                                  + phoneCharactersList.size());
            }
            
            progressBar.setMinimum(0);
            progressBar.setMaximum(phoneCharactersList.size());
            
            /* Iterate through all the character combinations now contained
               within the 'phoneCharactersList' and compare them to the words
               contained within the dictionary file. Store found words into 
               the foundList List Interface object. 
               Declare concurrent executor service threads (one for each possible 
               word to check for in dictionary file).      */
            java.util.concurrent.ExecutorService executor = 
                    java.util.concurrent.Executors.newFixedThreadPool(phoneCharactersList.size());
            for (int i = 0; i < phoneCharactersList.size(); i++) {
                String wordToFind = phoneCharactersList.get(i);
                label2.setText("<html><center>Processing word: <font color=yellow>" 
                               + wordToFind + "</font></center></html>");
                if (showProcess) {
                    System.out.println((i + 1) + ") Processing the possible word: " + wordToFind);
                }
                Runnable threadWorker = new Runnable() {
                    @Override
                    public void run() {
                        try (java.io.BufferedReader br = new java.io.BufferedReader(new java.io.FileReader(dictionaryFilePath))) {
                            String line;
                            while ((line = br.readLine()) != null) {
                                line = line.trim();
                                if (line.isEmpty() || (line.length() != wordToFind.length())) {
                                    continue;
                                }
                                if (line.equalsIgnoreCase(wordToFind)) {
                                    foundList.add(wordToFind.toUpperCase());
                                    break;
                                }
                            }
                        }
                        catch (Exception ex) {
                            System.err.println(ex);
                        }
                    }
                };
                executor.execute(threadWorker);
                progressBar.setValue(i+1);
            }
            // Shut down Executor Service threads (when they are done)
            executor.shutdown();
            // Hold rest of code processing until are executors are terminated.
            while (!executor.isTerminated()) {
            }

            return null;
        }

        @Override
        protected void done() {
            workingDialog.dispose();
            iframe.dispose();
            workingDialog.setCursor(java.awt.Cursor.getPredefinedCursor(java.awt.Cursor.DEFAULT_CURSOR));
        }
    };
    worker.execute();
    workingDialog.setVisible(true);
    try {
        worker.get();
    }
    catch (Exception e1) {
        e1.printStackTrace();
    }
    
    java.util.Collections.sort(foundList);
    long timeEnd = System.currentTimeMillis();
    if (showProcess) {
        long seconds = (timeEnd - timeStart) / 1000;
        String timeSpan = new StringBuffer("").append(String.valueOf(seconds))
                                    .append(" seconds").toString();
        if (seconds > 60) {
            timeSpan = new StringBuffer("").append(String.valueOf(seconds/60))
                        .append(" minutes and ").append(String.valueOf(seconds%60))
                        .append(" seconds").toString();
        }
        System.out.println(new StringBuffer("It took ").append(timeSpan)
                .append(" to process the number: ").append(telephoneNumber)
                .toString());
    }
    return foundList.toArray(new String[foundList.size()]);
}

Modify the code as you see fit so as to utilize your 2-3-4 Tree, B-Tree, or whatever you like. To use this method you might do it like this:

String phoneNumber = "26678837";
String[] words = telephoneNumberToDictionaryWords("dictionary.txt", phoneNumber, false);
if (words == null || words.length == 0) {
    System.out.println("There are no dictionary words available for "
            + "the Phone Number: " + phoneNumber);
}
else {
    for (String str : words) {
        System.out.println(str);
    }
}