Comment faire pour compter les occurrences de valeurs uniques dans le Dictionnaire?

La première chose à noter, c'est que vous n'avez pas de soins sur les touches du dictionnaire. La première étape est donc de les ignorer comme non pertinentes pour la tâche à accomplir. Nous allons travailler avec le Values propriété du dictionnaire, et le travail est le même que pour toute autre collection d'entiers (ou tout autre énumérable de tout autre type, nous pouvons comparer pour l'égalité).

Il y a deux méthodes courantes de ce problème, les deux sont bien la peine de savoir.

La première utilise un autre dictionnaire pour contenir le nombre de valeurs:

//Start with setting up the dictionary you described.
Dictionary<string, int> dict = new Dictionary<string, int>{
    {"key1", 2},
    {"key2", 2},
    {"key3", 3},
    {"key4", 2},
    {"key5", 5},
    {"key6", 5}
};
//Create a different dictionary to store the counts.
Dictionary<int, int> valCount = new Dictionary<int, int>();
//Iterate through the values, setting count to 1 or incrementing current count.
foreach(int i in dict.Values)
    if(valCount.ContainsKey(i))
        valCount[i]++;
    else
        valCount[i] = 1;
//Finally some code to output this and prove it worked:
foreach(KeyValuePair<int, int> kvp in valCount)//note - not sorted, that must be added if needed
    Console.WriteLine("{0} - {1}", kvp.Key, kvp.Value);

J'espère que c'est assez simple. Une autre approche est plus compliquée, mais a certains avantages:

//Start with setting up the dictionary you described.
Dictionary<string, int> dict = new Dictionary<string, int>{
    {"key1", 2},
    {"key2", 2},
    {"key3", 3},
    {"key4", 2},
    {"key5", 5},
    {"key6", 5}
};
IEnumerable<IGrouping<int, int>> grp = dict.Values.GroupBy(x => x);
//Two options now. One is to use the results directly such as with the
//equivalent code to output this and prove it worked:
foreach(IGrouping<int, int> item in grp)//note - not sorted, that must be added if needed
    Console.WriteLine("{0} - {1}", item.Key, item.Count());
//Alternatively, we can put these results into another collection for later use:
Dictionary<int, int> valCount = grp.ToDictionary(g => g.Key, g => g.Count());
//Finally some code to output this and prove it worked:
foreach(KeyValuePair<int, int> kvp in valCount)//note - not sorted, that must be added if needed
    Console.WriteLine("{0} - {1}", kvp.Key, kvp.Value);

(Nous aurions probablement utiliser var plutôt que de la verbose IEnumerable<IGrouping<int, int>>, mais il vaut la peine d'être précis lors de l'explication de code).

Dans une comparaison directe, cette version est inférieure à la fois plus complexe à comprendre et moins efficace. Cependant, l'apprentissage de cette approche permet une concis et efficace des variantes de la même technique, il est donc intéressant d'examiner.

GroupBy() prend une énumération et crée une autre énumération qui contient des paires clé-valeur où la valeur est une énumération trop. Le lambda x => x signifie que ce qu'il est regroupées par elle-même, mais nous avons la possibilité pour les différentes règles de regroupement que cela. Le contenu de grp ressemble un peu à:

{
  {Key=2, {2, 2, 2}}
  {Key=3, {3}}
  {Key=5, {5, 5}}
}

Donc, si nous bouclons ce un pour chaque groupe, nous tirez le Key et appel Count() sur le groupe, nous obtenons les résultats que nous voulons.

Maintenant, dans le premier cas, nous avons construit notre comte dans un seul O(n) passe, alors qu'ici nous construisons le groupe en O(n) passe, et puis obtenir le comte dans un deuxième temps O(n) passe, ce qui la rend beaucoup moins efficace. C'est aussi un peu plus difficile à comprendre, alors, pourquoi la peine de le mentionner?

Bien, la première est que, une fois que nous comprenons cela, nous pouvons nous tourner les lignes:

IEnumerable<IGrouping<int, int>> grp = dict.Values.GroupBy(x => x);
foreach(IGrouping<int, int> item in grp)
    Console.WriteLine("{0} - {1}", item.Key, item.Count());

Dans:

foreach(var item in dict.Values.GroupBy(x => x))
  Console.WriteLine("{0} - {1}", item.Key, item.Count());

Qui est assez concis, et devient idiomatiques. Il est particulièrement agréable si on veut ensuite aller sur et faire quelque chose de plus compliqué avec la valeur-nombre de paires que nous pouvons chaîne dans une autre opération.

La version qui met les résultats dans un dictionnaire peut être encore plus concis encore:

var valCount = dict.Values.GroupBy(x => x).ToDictionary(g => g.Key, g => g.Count());

Là, l'ensemble de votre réponse à la question dans une ligne courte, plutôt que le 6 (découpage des commentaires) pour la première version.

(Certains pourraient préférer remplacer dict.Values.GroupBy(x => x) avec dict.GroupBy(x => x.Value) qui aura exactement les mêmes résultats, une fois que nous courons le Count() sur elle. Si vous n'êtes pas sûr immédiatement pourquoi, essayer de s'en sortir).

L'autre avantage, c'est que nous avons plus de flexibilité avec GroupBy dans les autres cas. Pour ces raisons, les gens qui sont habitués à l'aide de GroupBy sont très susceptibles de commencer avec une ligne de la concision de dict.Values.GroupBy(x => x).ToDictinary(g => g.Key, g => g.Count()); et de changer pour le plus verbeux, mais plus effient forme de la première version (où on incrémente totaux en cours d'exécution dans le nouveau dictionnaire) si c'est une performance hotspot.

OriginalL'auteur Jon Hanna