Permutating Multiple Dictionary Values using C#

Question

Is there a way to use an IEnumerable For Each-Loop to parse through multiple definitions in a SortedDictionary? I would like to basically use it as a simple database structure I guess. For example, say my dictionary is used for spinning an article and looks like the following. For each word in a sentence (my string), I would create a new version of that string using a synonym (my definitions). Is this even the best option? This is what I have so far:

string testSentence = "Take it or beat it.";

List<string> allSynonyms = SynonymUtility.AlternativesOf(testSentence).ToList();
variations.AddRange(allSynonyms);


public class SynonymUtility
{
    private static readonly SortedDictionary<char, string> synonymList = new SortedDictionary<char, string>
    {
        {'but', "however"},
        {'take', "abduct, abstract, accroach"},
        {'beat', "hit, lash, punch, shake"},
        {'end', " butt, confine, cusp"};
    }

    public static IEnumerable<string> AlternativesOf(string arg)
    {
        arg = arg.ToLower();
        string[] words = arg.Split(" "));
        //END HERE I AM STUCK...
    }    

So as you can see, I am on my way to the solution, but I can't figure out how to take each of the split words and replace them with each of the synonyms in the dictionary. Each attempt would only replace one item...so there would be 9 permutations of the sentence string in the end.

Anyway, any help would be appreciated.

Answer 1

This solves your problem:

I have modified the structure of you synonym dictionary so that the values are Lists:

    private static readonly SortedDictionary<string, List<string>> synonymList 
            = new SortedDictionary<string, List<string>>
            {
                {"but", new List<string> { "however" }},
                {"take", new List<string> { "abduct", "abstract", "accroach"}},
                {"beat", new List<string> {"hit", "lash", "punch", "shake"}},
                {"end",  new List<string> {"butt", "confine", "cusp"}}
            };

Function to output all alternative sentences:

    public static IEnumerable<string> AlternativesOf(string arg)
    {
        //First of all, build up a 2d array of all your options
        var words = arg.Split(' ').Select(w=> w.ToLower()).ToList();
        var options = new List<List<string>>();

        foreach (var word in words)
        {
            if (synonymList.ContainsKey(word))
            {
                //Add the original word to the list of synonyms
                options.Add(synonymList[word]
                               .Concat(new List<string> { word }).ToList());
            }
            else
            {
                //Just use the original word only
                options.Add(new List<string> { word });
            }
        }

        //Now return all permutations of the 2d options array
        return AllPermutationsOf("", options, 0);
    }

Function to get all permutations:

    public static IEnumerable<string> AllPermutationsOf
           (string sentence, List<List<string>> options, int count)
    {
        if (count == options.Count)
        {
            yield return sentence;
        }
        else
        {
            foreach (string option in options[count])
            {
                foreach (var childOption in AllPermutationsOf
                             (sentence + " " + option, options, count + 1))
                {
                    yield return childOption;
                }
            }
        }
    }

Example usage:

 string testSentence = "Take it or beat it.";
 var alternatives = AlternativesOf(testSentence).ToList();

        /*  Output:

            abduct it or hit it.
            abduct it or lash it.
            abduct it or punch it.
            abduct it or shake it.
            abduct it or beat it.
            abstract it or hit it.
            abstract it or lash it.
            abstract it or punch it.
            abstract it or shake it.
            abstract it or beat it.
            accroach it or hit it.
            accroach it or lash it.
            accroach it or punch it.
            accroach it or shake it.
            accroach it or beat it.
            take it or hit it.
            take it or lash it.
            take it or punch it.
            take it or shake it.
            take it or beat it. */