Question

This is a question about returning efficiently strings and chars from a string array where:

1. The string in the string array starts with the user input supplied
2. The next letter of those strings as a collection of chars.

The idea is that when the user types a letter, the potential responses are displayed along with their next letters. Therefore response time is important, hence a performant algorithm is required.

E.g. If the string array contained:

string[] stringArray = new string[] { "Moose", "Mouse", "Moorhen", "Leopard", "Aardvark" };

If the user types in “Mo”, then “Moose”, “Mouse” and “Moorhen” should be returned along with chars “o” and “u” for the potential next letters.

This felt like a job for LINQ, so my current implementation as a static method is (I store the output to a Suggestions object which just has properties for the 2 returned lists):

public static Suggestions 
GetSuggestions
    (String userInput, 
    String[] stringArray)
{
    // Get all possible strings based on the user input. This will always contain
    // values which are the same length or longer than the user input.
    IEnumerable<string> possibleStrings = stringArray.Where(x => x.StartsWith(userInput));
    IEnumerable<char> nextLetterChars = null;

    // If we have possible strings and we have some input, get the next letter(s)
    if (possibleStrings.Any() &&
        !string.IsNullOrEmpty(userInput))
    {
        // the user input contains chars, so lets find the possible next letters.
        nextLetterChars =
            possibleStrings.Select<string, char>
            (x =>
            {
                // The input is the same as the possible string so return an empty char.
                if (x == userInput)
                {
                    return '\0';
                }
                else
                {
                    // Remove the user input from the start of the possible string, then get
                    // the next character.
                    return x.Substring(userInput.Length, x.Length - userInput.Length)[0];
                }
            });
    } // End if

I implemented a second version which actually stored all typing combinations to a list of dictionaries; one for each word, with key on combination and value as the actual animal required, e.g.:

• Dictionary 1:
• Keys Value
• “M” “Moose”
• “MO “Moose”

Etc.

• Dictionary 2:
• Keys Value
• “M” “Mouse”
• “MO” “Mouse”

Etc.

Since dictionary access has an O(1) retrieval time – I thought perhaps this would be a better approach.

So for loading the dictionaries at start up:

    List<Dictionary<string, string>> animalCombinations = new List<Dictionary<string, string>>();
    foreach (string animal in stringArray)
    {
        Dictionary<string, string> animalCombination = new Dictionary<string, string>();
        string accumulatedAnimalString = string.Empty;
        foreach (char character in animal)
        {
            accumulatedAnimalString += character;
            animalCombination[accumulatedAnimalString] = animal;
        }

        animalCombinations.Add(animalCombination);
    }

And then at runtime to get possible strings:

    // Select value entries from the list of dictionaries which contain
    // keys which match the user input and flatten into one list.
    IEnumerable<string> possibleStrings = 
        animalCombinations.SelectMany
            (animalCombination => 
                {
                    return animalCombination.Values.Where(x =>
                        animalCombination.ContainsKey(userInput));
                });

So questions are:

1. Which approach is better?
2. Is there a better approach to this which has better performance?
3. Are LINQ expressions expensive to process?

Thanks

Answer 1

Which approach is better?

Probably the dictionary approach, but you’ll have to profile to find out.

Is there a better approach to this which has better performance?

Use a prefix tree.

Are LINQ expressions expensive to process?

Written correctly, they add very little overhead to imperative versions of the same code. Since they are easier to read and maintain and write, they are usually the way to go.