Introduction

In a recent article, Permutations in C# Using Recursion, I demonstrated the use of a recursive algorithm to calculate all permutations of a given set of items. The algorithm was one of three algorithms introduced in Alexander Bogomolny’s article, Counting and Listing All Permutations. The article can be found on the Interactive Mathematics Miscellany and Puzzles website. In this article and accompanying application, I will use the recursive algorithm to create a word descrambler. Based on a twist to the classic Jumble puzzle, the user inputs a string of 2 to 7 randomly ordered characters. The application will attempt to ‘unscramble’ the string by deriving all permutations of the input string and then searching for them in an English-language dictionary.

Note, you can choose to input any type of characters – letters, numbers, or symbols. All unique permutations will be returned. However, only character-only strings will be correctly identified as known words by the application.

Background

We've all seen the Jumble word scramble game in the newspaper. An example of this classic puzzle game can also be found online at UCLICKgames.com. The letters that make up a word are displayed in a random order. The goal is to rearrange the letters and discover the hidden word. Jumble puzzles normally have only one right answer. Jumble puzzles usually range from simple four-letter words to harder-to-solve six-letter words. While four letters have only 120 possible permutations, six letters have six times as many possible permutations (720), making them much harder to solve.

The application uses the recursive algorithm to solve the puzzle very similar to how we might solve it. We usually start visualizing or jotting down combinations of letters in the puzzle until we chance upon a recognizable word. Sometimes, we just ‘see’ the word right off; other times we struggle incessantly for the answer. Of course, sometimes the answer eludes us because of the limits of our vocabulary. We chance upon a word, but since we are unfamiliar with it, we discount it and continue permuting. Unlike us, the application can quickly search an entire dictionary for all possible matches.

Using the Code

To demonstrate the use of recursive algorithm to descramble a string of characters, I have created a simple Windows Forms Application. The application is built in C# 3.0, using Visual Studio 2008, on the .NET Framework 3.5. It consists of a single Windows form and a separate, small class file containing the methods, fields, and properties that define the game’s logic. As discussed earlier, the application uses Bogomolny’s original methods, which have been converted to C# from Java. The original methods, fields, and properties are renamed to create more readable, easy-to-understand C# code.

Below is the Permutations.cs class file, which contains the game’s logic. The actual source code has full commenting for each method.

Microsoft Word 11.0 Object Library

The application uses the spell checking capabilities of Microsoft Office Word 2003 to determine if each permutation is a recognized word. I did so adding a COM reference to the Microsoft Word 11.0 Object Library assembly to the project. If you own Microsoft Office Word 2007, you will need to add the Microsoft Word 12.0 Object Library assembly to your project. Using COM or Microsoft Word are not necessarily the best, or the only solutions. There are other applications and utilities, including freeware, which could be interfaced with the application. An alternate approach would be a web service. Each permutation or a list of permutations could be sent to a remote web service, which would provide spell checking.

To minimize memory usage, the application creates a single instance of the Word Application interface (wordApp) to call the CheckSpelling(string theWord) method for each individual permutation. When complete or when an exception occurs, the wordApp object is destroyed by calling the Quit() method. When wordApp is processing permutations, you will note an instance of WINWORD.EXE running in Task Manager’s Processes tab.

The Descrambler Process

Construct a character array from the string input by the user (ex. cdeo -> {c, d, e, o}).

Use the recursive algorithm to calculate each permutation of the characters based on the character’s position (example: {1, 4, 2, 3}).

Create the character permutation, by matching the numeric position-based permutation to the corresponding characters in the character array (ex. {1, 4, 2, 3} -> {c, o, d, e}).

Store the character permutation as a string in a List<string> object (ex. {code}).

Remove any duplicate permutations from the List<string>. See explanation below.

Use LINQ’s Where()extension to send each permutation in the List<string> to the CheckSpelling(string theWord) method, which in turn calls Microsoft Word.

Store only those permutations that have a return Boolean value from the CheckSpelling(string theWord) method of true, indicating the permutation was found in Word’s dictionary, in a second List<string> object.

Return a sorted list of all permutations to the user, with correct answer(s) listed first. Also included at the end is a summary of the results.

The recursive algorithm’s methods are very fast, while passing the results to the Word object for spell checking can be time consuming. A progress bar at the bottom of the UI is updated as each permutation is spell-checked by Word. It is important not to change windows while the application is running.

Handling Duplicate Permutations

Unlike the Console Application in the previous article, this Windows Application removes duplicate permutations using LINQ’s Distinct() extension. Duplicates are produced when identical characters exist in the input string, producing duplicate permutations. For example, the word ‘tester’ has two letter t’s and two e’s, which would generate 540 duplicate permutations out a total of 720 possible permutations. Permutations in the existing List<string> are copied to a second List<string> object using LINQ’s Distinct() extension, eliminating duplicates. See the example below, which has been foreshortened for display purposes.

Installing the Source Code

To use the source code, create a Windows Forms Application in Microsoft Visual Studio 2008 entitled ‘Unscramble’. Replace the default Form1.cs files with the source code’s Form1.cs files. Add in the Permutations.cs class file. Lastly, add a COM reference to the Microsoft Word 11.0 Object Library assembly (Microsoft.Office.Interop.Word). In doing so, two other assemblies, Microsoft.Vbe.Interop and Interop.Microsoft.Office.Core, will be automatically added to your project’s reference folder. If you implement an alternate spell checking method other than Word, you will need to modify the CheckTheSpelling(string) method.

Share

About the Author

I am a senior software developer, architect, and project manager, specializing in .NET, JavaScript, Java, and database development, and build automation. I am currently a Lead Developer (.NET) / Developer IV for Paychex Enterprise Business Solutions. Paychex (PAYX) provides payroll, human resources, and benefits outsourcing and web-based solutions to business.

Prior to Paychex, I served as Lead Software Engineer, Operations Manager, and Technical Product Manager at Bio-Optronics. Bio-Optronics develops, deploys and operates information technology solutions to help healthcare professionals manage and optimize workflow to enhance quality, productivity, and patient and staff satisfaction and safety. Previously, I held positions of President, COO, Chief Technology Officer (CTO), and SVP of Technology for Lazer Incorporated. Lazer is a successful, digital imaging and Internet-based content management services provider.

Comments and Discussions

plzzz help me with this one i do not understand the coding just i need this program for 28 charters i donot care if it will take all the day just i need some one send it redy for me > plzzzzzzzzzzzzzzzalyaqoot-almlky@hotmail.com

I did this for fun about a year ago and approached it in a slightly different manner - creating a list of all possible permutations could become horrific when longer words are used!

My method was to take a dictionary of words (easily obtained on the net). Next, generate a "hash" of each word which would be a 26 character numeric code with each position representing the number of times any given letter occurred. E.g. the word DAB would be represented by 000.....001011 - as would the word BAD.

You have therefore effectively solved all your anagrams at the time when the dictionary is created. Any given key will have associated with it every word that can be made from the given set of letters.

This method is fine until someone invents a word with 10 or more repetitions of the same letter!

If we are searching for an exact match (a perfect anagram) then we merely generate the hash from the input letters and lookup the matches.

If we want all the combinations of smaller words within the letters then I also used recursion to generate all the letter combinations (which don't need to be stored) having first sorted the letters into alphabetical order. That way, we know that if the current letter is the same as the last letter, we can ignore that step in the recursion as it will generate a duplicate result.

Rich,
Thank you. I like your approach, also. I figured members of CodeProject would be have much more creative, and timely approaches to checking the permutation against known words then using COM. I would think the most dynamic approach would be a web service, which would be constantly up-to-date, and/or could be pointed to multi-lingual sources if necessary. I have considered adding the added feature of finding all words (sub-strings of the main string), to exemplify the expanded use of recursion.

Once upon a time, I wrote a program that could take a dictionary and determine whether there existed any combination of words in the dictionary which would use each letter precisely once. The approach was similar, though I used 26 bits of a 32-bit 'long' variable to encode each word. I had 26 lists of words, based upon the most-significant set bit. I implemented a simple recursive search: check each word in the current list to make sure it doesn't have any 'disqualifying' letters; if it doesn't, mask out that word's letters from the set of letters remaining and search to see if the remaining set is solvable.

Using the default usr/dict/words, there was no trouble finding workable sets, since that list includes things like the symbols of elements (C, Hg, etc.), but I didn't find those results particularly rewarding. I don't remember exactly what I came up with as results, but they tended to include "seq", "dr", and "tv".

Searching for sets with a small number of extra letters would probably yield more interesting results, but would probably require a more complicated algorithm. If I still had my code, it might be interesting to hack it to ignore certain letters (e.g. produce lists of words that contain every letter but 'e' multiple times, and see which list has the fewest 'e's, then try the same thing with other vowels).