CODEWITHSUNDEEP
c#linqdictionary
yoad w
yoad w

Reputation: 325

Searching for dictionary keys contained in a string array

I have a List of strings where each item is a free text describing a skill, so looks kinda like this:

List<string> list = new List<string> {"very good right now", "pretty good",
 "convinced me that is good", "pretty medium", "just medium" .....}

And I want to keep a user score for these free texts. So for now, I use conditions:

foreach (var item in list)
        {
            if (item.Contains("good"))
            {
                score += 2.5;
                Console.WriteLine("good skill, score+= 2.5, is now {0}", score);
            }
            else if (item.Contains(low"))
            {
                score += 1.0;
                Console.WriteLine("low skill, score+= 1.0, is now {0}", score);
            }

        }

Suppose In the furure I want to use a dictionary for the score mapping, such as:

Dictionary<string, double> dic = new Dictionary<string, double>
{ { "good", 2.5 }, { "low", 1.0 }};

What would be a good way to cross between the dictionary values and the string list? The way I see it now is do a nested loop:

foreach (var item in list)
        {
            foreach (var key in dic.Keys)
                if (item.Contains(key))
                    score += dic[key];
        }

But I'm sure there are better ways. Better being faster, or more pleasant to the eye (LINQ) at the very least.

Thanks.

Upvotes: 5

Views: 248

Answers (4)

Sergey Berezovskiy
Sergey Berezovskiy

Reputation: 236208

var scores = from item in list
             from word in item.Split()
             join kvp in dic on word equals kvp.Key
             select kvp.Value;

var totalScore = scores.Sum();

Note: your current solution checks whether the item in the list contains key in the dictionary. But it will return true even if key in dictionary is a part of some word in the item. E.g. "follow the rabbit" contains "low". Splitting item into words solves this issue.

Also LINQ join uses hash set internally to search first sequence items in second sequence. That gives you O(1) lookup speed instead of O(N) when you enumerating all entries of dictionary.

Upvotes: 2

James Curran
James Curran

Reputation: 103485

Well, you aren't really using the Dictionary as a dictionary, so we can simplify this a bit with a new class:

class TermValue
{
    public string Term { get; set; }
    public double Value { get; set; }

    public TermValue(string t, double v)
    {
        Term = t;
        Value = v;
    }
}

With that, we can be a bit more direct:

void Main()
{
    var dic = new TermValue[] { new TermValue("good", 2.5), new TermValue("low", 1.0)};


    List<string> list = new List<string> {"very good right now", "pretty good",
 "convinced me that is good", "pretty medium", "just medium" };

    double score = 0.0;
    foreach (var item in list)
    {
        var entry = dic.FirstOrDefault(d =>item.Contains(d.Term));
        if (entry != null)
            score += entry.Value;
    }
}

From here, we can just play a bit (the compiled code for this will probably be the same as above)

    double score = 0.0;
    foreach (var item in list)
    {
        score += dic.FirstOrDefault(d =>item.Contains(d.Term))?.Value ?? 0.0;
    }

then, (in the word of the Purple One), we can go crazy:

double score = list.Aggregate(0.0, 
     (scre, item) =>scre + (dic.FirstOrDefault(d => item.Contains(d.Term))?.Value ?? 0.0));

Upvotes: 0

Mark Shevchenko
Mark Shevchenko

Reputation: 8197

If your code finds N skill strings containing the word "good" then it appends score 2.5 N times.

So you can just count skill strings containing dictionary work and multiply the value on corresponding score.

var scores = from pair in dic
             let word = pair.Key
             let score = pair.Value
             let count = list.Count(x => x.Contains(word))
             select score * count;

var totalScore = scores.Sum();

Upvotes: 2

Jonesopolis
Jonesopolis

Reputation: 25370

its not faster really, but you can use LINQ:

score = list.Select(s => dic.Where(d => s.Contains(d.Key))
            .Sum(d => d.Value))
            .Sum();

note that your example loop will hit 2 different keys if he string matches both, I kept that in my solution.

Upvotes: 1

Related Questions