Building a dictionary of counts of items in a list

Question

I have a List containing a bunch of strings that can occur more than once. I would like to take this list and build a dictionary of the list items as the key and the count of their occurrences as the value.

Example:

List<string> stuff = new List<string>();
stuff.Add( "Peanut Butter" );
stuff.Add( "Jam" );
stuff.Add( "Food" );
stuff.Add( "Snacks" );
stuff.Add( "Philosophy" );
stuff.Add( "Peanut Butter" );
stuff.Add( "Jam" );
stuff.Add( "Food" );

and the result would be a Dictionary containing:

"Peanut Butter", 2
"Jam", 2
"Food", 2
"Snacks", 1
"Philosophy", 1

I have a way to do this, but it doesn't seem like I'm utilizing the good stuff in C# 3.0

public Dictionary<string, int> CountStuff( IList<string> stuffList )
{
    Dictionary<string, int> stuffCount = new Dictionary<string, int>();

    foreach (string stuff in stuffList) {
        //initialize or increment the count for this item
        if (stuffCount.ContainsKey( stuff )) {
            stuffCount[stuff]++;
        } else {
            stuffCount.Add( stuff, 1 );
        }
    }

    return stuffCount;
}

casperOne · Accepted Answer · 2020-07-29T12:50:41.700

29

You can use the group clause in C# to do this.

List<string> stuff = new List<string>();
...

var groups = 
    from s in stuff
    group s by s into g
    select new { 
        Stuff = g.Key, 
        Count = g.Count() 
    };

You can call the extension methods directly as well if you want:

var groups = stuff
    .GroupBy(s => s)
    .Select(s => new { 
        Stuff = s.Key, 
        Count = s.Count() 
    });

From here it's a short hop to place it into a Dictionary<string, int>:

var dictionary = groups.ToDictionary(g => g.Stuff, g => g.Count);

edited Jul 29 '20 at 12:50

answered Mar 26 '09 at 19:59

casperOne

73,706
19
184
253

How would you add an orderby to the first example? – zadam Mar 02 '10 at 06:27
@zadam You can always say `groups = groups.OrderBy(g => g.Stuff)`; – casperOne May 20 '16 at 14:55

score 9 · Answer 2 · answered Mar 26 '09 at 20:06

I would have made a specialized List, that backed by the Dictionary and the add method would test for membership and increase count if found.

sorta like:

public class CountingList
{
    Dictionary<string, int> countingList = new Dictionary<string, int>();

   void Add( string s )
   {
        if( countingList.ContainsKey( s ))
             countingList[ s ] ++;
        else
            countingList.Add( s, 1 );
   }
}

Aryan Firouzian · Answer 3 · 2018-09-07T23:15:19.770

1

Dictionary<string, int> a = stuff.GroupBy(p => p).OrderByDescending(r=>r.Count()).ToDictionary(q => q.Key, q => q.Count());

You can GroupBy and then create dictionary to count each group. As performance test indicate, usually there are more efficient approaches other than Linq. I think your code is more efficient, while Linq solution is more readable and beautiful.

edited Sep 07 '18 at 23:15

answered Sep 01 '18 at 10:15

Aryan Firouzian

1,940
5
27
41

score 1 · Answer 4 · edited May 23 '17 at 12:34

1

One idea would be to give the dictionary a default value of zero, so you wouldn't have to special case the first occurrence.

edited May 23 '17 at 12:34

Community

1
1

answered Mar 26 '09 at 19:58

MarkusQ

21,814
3
56
68

Well, that would just be moving the code that handles the special case into a separate class... – Guffa Mar 26 '09 at 20:04

score 0 · Answer 5 · answered Mar 26 '09 at 20:02

0

Well, there isn't really any better way to do it.

Perhaps you could write a LINQ query that would group the strings and then count how many strings there are in each group, but that would not be nearly as efficient as what you already have.

answered Mar 26 '09 at 20:02

Guffa

687,336
108
737
1,005

Building a dictionary of counts of items in a list

5 Answers5

Linked