在C＃中查询扩展逻辑

Question

I have to write logic for expanding queries for solr search engine. I am using Dictionary<string, string> dicSynon = new Dictionary<string, string>(); .

Each time I will be getiing strings like "2 ln ca". In my dictionary I am having synonyms for ln and ca as lane and california. Now I need to pass solr all the combination of strings. Like this

2 ln ca
2 lane ca
2 lane california
2 ln california

Please help me to build the logic....

Answer 1

This is a exercise in using combinatorics and Linqs SelectMany:

First you have to writeyourself some function to give you a sequence of synonyms given a word (including the word, so "2" will result in ("2")) - let's call this 'Synonmys' - using a dictionary it can look like this:

private Dictionary<string, IEnumerable<string>> synonyms = new Dictionary<string, IEnumerable<string>>();

public IEnumerable<string> GetSynonmys(string word)
{
    return synonyms.ContainsKey(word) ? synonyms[word] : new[]{word};
}

(you have to fill the Dictionary yourself...)

Having this your task is rather easy - just think on it. You have to combine every synonym of a word with all the combinations you get from doing the task on the rest of the words - that's exactly where you can use SelectMany (I only paste the rest seperated by a space - maybe you should refactor a bit) - the Algorithm yourself is your standard recursive combinations-algorithm - you will see this a lot if you know this kind of problem:

public string[] GetWords(string text)
{
    return text.Split(new[]{' '}); // add more seperators if you need
}

public IEnumerable<string> GetCombinations(string[] words, int lookAt = 0)
{
    if (lookAt >= words.Length) return new[]{""};

    var currentWord = words[lookAt];
    var synonymsForCurrentWord = GetSynonmys(currentWord);
    var combinationsForRest = GetCombinations(words, lookAt + 1);

    return synonymsForCurrentWord.SelectMany(synonym => combinationsForRest.Select(rest => synonym + " " + rest));
}

Here is a complete example:

class Program
{
    static void Main(string[] args)
    {
        var test = new Synonmys(Tuple.Create("ca", "ca"),
                                Tuple.Create("ca", "california"),
                                Tuple.Create("ln", "ln"),
                                Tuple.Create("ln", "lane"));

        foreach (var comb in test.GetCombinations("2 ln ca"))
            Console.WriteLine("Combination: " + comb);
    }
}

class Synonmys
{
    private Dictionary<string, IEnumerable<string>> synonyms;

    public Synonmys(params Tuple<string, string>[] syns )
    {
        synonyms = syns.GroupBy(s => s.Item1).ToDictionary(g => g.Key, g => g.Select(kvp => kvp.Item2));
    }

    private IEnumerable<string> GetSynonmys(string word)
    {
        return synonyms.ContainsKey(word) ? synonyms[word] : new[]{word};
    }

    private string[] GetWords(string text)
    {
        return text.Split(new[]{' '}); // add more seperators if you need
    }

    private IEnumerable<string> GetCombinations(string[] words, int lookAt = 0)
    {
        if (lookAt >= words.Length) return new[]{""};

        var currentWord = words[lookAt];
        var synonymsForCurrentWord = GetSynonmys(currentWord);
        var combinationsForRest = GetCombinations(words, lookAt + 1);

        return synonymsForCurrentWord.SelectMany(synonym => combinationsForRest.Select(rest => synonym + " " + rest));
    }

    public IEnumerable<string> GetCombinations(string text)
    {
        return GetCombinations(GetWords(text));
    }

}

Feel free to comment if something is not crystal-clear here ;)