Since I keep receiving entries to my programming challenge, I’ve compiled a list.  New entries will be added to that list as they are received.

 

Last Saturday (4/3/04) I received another C# solution from Frans Bouma.  In his own words:

 

“Hi,

 

This week I started my phraser solution in C#, and today I finished it. As you had to make it as clean as possible I did, and it might look somewhat verbose through the comments (no not // add 1 comments ;)).

 

The core phraser routine is just 34 lines with half of them { and } or comments.

 

I paste the complete code below. As a wordlist, you should simply use a textfile and on each line 1 word.

 

When you compile the code, simply run it like:

phraser.exe 6423946369 words.txt 2

 

where 2 is the maximum amount of digits. You can also specify -1 which means no limit.

 

The algo is performing ok and can be made even faster with a more clever hashtable setup, as I've explained in the comments :)

 

Cheers, and thanks for this fun compo. :)”

 

using System;

using System.Collections;

using System.IO;

 

namespace Phraser

{

    /// <summary>

    /// Phrase creator class, which creates all phrases possible of a phone number, using a word list.

    /// The algorithm used: read all words in the wordlist and encode them into digit sequences (thus the

    /// digit sequence required to form the word using the phone keyboard). Then match the digit sequences

    /// with the phone number digits to find words in the phone number.

    /// This is more efficient than the other algorithm: calculate all permutations of possible character

    /// sequences which can be formed with the phone number.

    /// </summary>

    public class PhraseCreator

    {

        #region Class Member Declarations

        private   Hashtable         _word2DigitSequence;

        private string              _phoneNumber, _wordListFilename;

        private int                       _maxAmountOfDigitsInPhrase;

        #endregion

 

        #region Constructors

        /// <summary>

        /// Constructor.

        /// </summary>

        /// <param name="phoneNumber">The phone number to transform into phrases</param>

        /// <param name="wordlistFilename">The filename with the english words to use in phrases.</param>

        /// <param name="maxAmountOfDigitsInPhrase">The maximum amount of digits to be placed in the phrase.

        /// -1 means unlimited.</param>

        public PhraseCreator(string phoneNumber, string wordListFilename, int maxAmountOfDigitsInPhrase)

        {

            _phoneNumber = phoneNumber;

            _wordListFilename = wordListFilename;

            _word2DigitSequence = new Hashtable();

            _maxAmountOfDigitsInPhrase = maxAmountOfDigitsInPhrase;

        }

        #endregion

 

        #region Public methods

        /// <summary>

        /// Initializes the class for the phrasing process.

        /// Loads wordlist and encodes all words read into digit sequences. Wordlists have to have 1 word per

        /// line. Skips all words which are longer than the specified phonenumber.

        /// </summary>

        public void Initialize()

        {

            StreamReader reader = null;

            string wordFromFile;

 

            try

            {

                reader = new StreamReader(_wordListFilename);

 

                // loop through the lines in the file. Each word is on a single line. Strip whitespace

                while((wordFromFile = reader.ReadLine()) != null)

                {

                    wordFromFile = wordFromFile.Trim();

                    if((wordFromFile.Length==0) || (wordFromFile.Length>_phoneNumber.Length))

                    {

                        // not valid.

                        continue;

                    }

 

                    // line read, each line contains 1 word. Create digit sequence for word read and store it in

                    // the hashtable.

                    wordFromFile = wordFromFile.ToLower();

 

                    // transform it to a digit sequence so we can use it for easy matching later.

                    string wordAsDigits = DigitizeWord(wordFromFile);

 

                    // store both in hashtable

                    if(!_word2DigitSequence.ContainsKey(wordFromFile))

                    {

                        _word2DigitSequence.Add(wordFromFile, wordAsDigits);

                    }

                }

            }

            finally

            {

                reader.Close();

            }

        }

 

 

        /// <summary>

        /// Starts the phrasing process by calling the routine which dives into the recursion.

        /// </summary>

        public void StartPhrasingProcess()

        {

            DoCreatePhrases(0, "", 0);

        }

 

        #endregion

 

 

        #region Private methods

        /// <summary>

        /// Creates all the possible phrases for the phone number passed in in the constructor.

        /// It uses the read words in the file which filename was passed in in the constructor.

        /// </summary>

        /// <param name="startIndex">the current index to start scanning in the phonenumber</param>

        /// <param name="phraseInProgress">the phrase which is currently being build</param>

        /// <param name="currentAmountOfDigits">the current amount of digits in the phraseInProgress</param>

        /// <remarks>

        /// It uses a simple algorithm. It walks all words read and uses their digit sequence representations to

        /// find them back in the phone number passed in starting with the first digit, and so on. If the current

        /// digit in the phone number is not usable in any word, it is kept as a digit in the phrase. After the

        /// complete wordlist has been processed for the current index, the digit is kept and the current index is

        /// increased with 1. Until the end of the phone number is reached and recursion stops and back tracks. The

        /// amount of digits is limited by the amount passed to the constructor. A '-' is placed between words.

        /// <br><br>

        /// It will write all found phrases to the console. Although the algorithm is very fast, it can be sped up

        /// even more by constructing a hashtable with per digit (0-9) a list of words which digit sequence representations

        /// start with that digit. This would greatly reduce  the amount of words to loop through for each digit position.

        /// </remarks>

        private void DoCreatePhrases(int startIndex, string phraseInProgress, int currentAmountOfDigits)

        {

            if(startIndex >= _phoneNumber.Length)

            {

                // we have scanned the complete phonenumber through recursion. We can exit now by printing the phrase

                // we've found to the console.

                Console.WriteLine("Phrase found: {0}", phraseInProgress);

                return;

            }

 

            string newPhraseInProgress = String.Empty;

            foreach(DictionaryEntry wordDigitSequencePair in _word2DigitSequence)

            {

                string wordAsDigitSequence = (string)wordDigitSequencePair.Value;

 

                // check if word matches the digits starting on startindex in phonenumber. If so, we have found a word.

                if((startIndex + wordAsDigitSequence.Length) > _phoneNumber.Length)

                {

                    // word can never match as it is longer than the remaining digits.

                    continue;

                }

                if(_phoneNumber.Substring(startIndex, wordAsDigitSequence.Length) == wordAsDigitSequence)

                {

                    // Match found. Dive into recursion with this new phraseInProgress

                    DoCreatePhrases(startIndex + wordAsDigitSequence.Length, MakeNewCurrentPhrase(phraseInProgress,

                        wordDigitSequencePair.Key.ToString()), currentAmountOfDigits);

                }

            }

 

            if((_maxAmountOfDigitsInPhrase == -1) || (_maxAmountOfDigitsInPhrase > currentAmountOfDigits))

            {

                // simply use the digit as a 'word' in the phrase and continue with the next digit. Then dive into recursion

                // with this new phraseInProgress

                DoCreatePhrases(startIndex+1, MakeNewCurrentPhrase(phraseInProgress, _phoneNumber[startIndex].ToString()),

                    currentAmountOfDigits+1);

            }

        }

 

 

        /// <summary>

        /// Creates a new phrase based on the two inputs. If the current phrase is empty, no '-' is emitted.

        /// </summary>

        /// <param name="currentPhrase">the current phrase we're working on</param>

        /// <param name="wordToAdd">the new word to add to the current phrase</param>

        /// <returns>new current phrase</returns>

        private string MakeNewCurrentPhrase(string currentPhrase, string wordToAdd)

        {

            if(currentPhrase.Length > 0)

            {

                return currentPhrase + "-" + wordToAdd;

            }

            else

            {

                return wordToAdd;

            }

        }

 

 

        /// <summary>

        /// Transforms the passed in word into a sequence of digits, the same sequence which is required to press

        /// on a phone keyboard to form the word.

        /// </summary>

        /// <param name="word">The word to transform into digits</param>

        /// <returns>The word as a string of digits</returns>

        /// <example>"nice" will be transformed into: "6423"</example>

        private string DigitizeWord(string word)

        {

            // get word as characters

            char[] wordAsCharacters = word.ToCharArray();

            char[] wordAsDigitSequence = new char[wordAsCharacters.Length];

 

            // digitize the word using CharacterToDigit

            for (int i = 0; i < wordAsCharacters.Length; i++)

            {

                wordAsDigitSequence[i] = CharacterToDigit(wordAsCharacters[i]);

            }

 

            // create a new string from the digits which are stored as characters.

            return new string(wordAsDigitSequence);

        }

 

 

        /// <summary>

        /// Transforms the passed in character, which can be a member of the range a-z, to a digit, which can be

        /// 2-9 (as only the keys 2-9 have characters on them on a phone keyboard).

        /// </summary>

        /// <param name="character">The character to transform into a digit</param>

        /// <returns>The digit representation of the passed in character.</returns>

        /// <example>'n' will be transformed into '6'</example>

        private char CharacterToDigit(char character)

        {

            // set variable to return to a default: 2.

            char digitToReturn = '2';

 

            // do the transformation.

            switch(character)

            {

                case 'a':

                case 'b':

                case 'c':

                    digitToReturn = '2';

                    break;

                case 'd':

                case 'e':

                case 'f':

                    digitToReturn = '3';

                    break;

                case 'g':

                case 'h':

                case 'i':

                    digitToReturn = '4';

                    break;

                case 'j':

                case 'k':

                case 'l':

                    digitToReturn = '5';

                    break;

                case 'm':

                case 'n':

                case 'o':

                    digitToReturn = '6';

                    break;

                case 'p':

                case 'q':

                case 'r':

                case 's':

                    digitToReturn = '7';

                    break;

                case 't':

                case 'u':

                case 'v':

                    digitToReturn = '8';

                    break;

                case 'w':

                case 'x':

                case 'y':

                case 'z':

                    digitToReturn = '9';

                    break;

            }

 

            return digitToReturn;

        }

        #endregion

 

    }

 

 

    /// <summary>

    /// Startup class for the application.

    /// </summary>

    public class Startup

    {

        /// <summary>

        /// The main entry point for the application.

        /// Expects 3 parameters:

        /// parameter 1: phone number to phrase.

        /// parameter 2: filename with English words.

        /// parameter 3: max amount of digits to place in the phrase. can be -1, which means 0 maximum set.

        /// </summary>

        [STAThread]

        static void Main(string[] args)

        {

            // check input

            if(args.Length < 3)

            {

                // wrong amount of arguments

                Console.WriteLine("Usage: Phraser Phonenumber Filename MaxAmountOfDigits" + Environment.NewLine +

                    "where 'Filename' is the file with words to use" + Environment.NewLine +

                    "where 'MaxAmountOfDigits is the maximum amount of digits to end up in the phrase. Can be -1 (no limit)");

                return;

            }

 

            try

            {

                // 3 arguments specified. Create the phrases. Use the PhraseCreator class to do that.

                PhraseCreator thePhraser = new PhraseCreator(args[0], args[1], Convert.ToInt32(args[2]));

                thePhraser.Initialize();

                // perform the phrasing

                thePhraser.StartPhrasingProcess();

            }

            catch(Exception ex)

            {

                // display the exception in the console.

                Console.WriteLine("Exception caught: {0}", ex.Message);

                Console.WriteLine("Source: {0}", ex.Source);

                Console.WriteLine("Stacktrace: {0}", ex.StackTrace);

            }

        }

    }

}