Pregunta simple de LINQ en C#

Question

Estoy tratando de usar LINQ para devolver el elemento que ocurre el número máximo de veces Y el número de veces que ocurre.

Por ejemplo: tengo una matriz de cadenas:

string[] words = { "cherry", "apple", "blueberry", "cherry", "cherry", "blueberry" }; 

//... 
Some LINQ statement here 
//... 

En esta matriz, la consulta volvería cherry como el máximo elemento se produjo, y 3 como el número de veces que se haya producido. Yo también estaría dispuesto a dividirlas en dos consultas si es necesario (es decir, primera consulta para obtener el cherry, y el segundo para devolver el recuento de 3.

Answer 1

var topWordGroup = words.GroupBy(word => word).OrderByDescending(group => group.Count()).FirstOrDefault(); 
// topWordGroup might be a null! 
string topWord = topWordGroup.Key; 
int topWordCount = topWordGroup.Count; 

Y en caso de que si no nos gusta O(N log N):

var topWordGroup = words.GroupBy(word => word).Aggregate((current, acc) => current.Count() < acc.Count() ? acc : current); 

Answer 2

primera cosa que viene a la mente (es decir, hay probablemente una manera más eficiente)

var item = words.GroupBy(x => x).OrderByDescending(x => x.Count()).First() 
//item.Key is "cherry", item.Count() is 3 

EDITAR: olvidó op quería el nombre y el recuento

Answer 3

Intente éste:

Converting SQL containing top, count, group and order to LINQ (2 Entities)

Answer 4

string[] words = { "cherry", "apple", "blueberry", "cherry", "cherry", "blueberry" }; 

var topWordAndCount=words 
    .GroupBy(w=>w) 
    .OrderByDescending(g=>g.Count()) 
    .Select(g=>new {Word=g.Key,Count=g.Count()}) 
    .FirstOrDefault(); 

//if(topWordAndCount!=null) 
//{ 
// topWordAndCount.Word 
// topWordAndCount.Count 

Answer 5

string[] words = { "cherry", "apple", "blueberry", "cherry", "cherry", "blueberry" }; 

var r = words.GroupBy (x => x) 
      .OrderByDescending (g => g.Count()) 
      .FirstOrDefault(); 
Console.WriteLine (String.Format ("The element {0} occurs {1} times.", r.Key, r.Count())); 

Answer 6

Las soluciones presentadas hasta ahora son O(n log n). Aquí es una solución O(n):

var max = words.GroupBy(w => w) 
       .Select(g => new { Word = g.Key, Count = g.Count() }) 
       .MaxBy(g => g.Count); 
Console.WriteLine(
    "The most frequent word is {0}, and its frequency is {1}.", 
    max.Word, 
    max.Count 
); 

Esto necesita una definición de MaxBy. He aquí uno:

public static TSource MaxBy<TSource>(
    this IEnumerable<TSource> source, 
    Func<TSource, IComparable> projectionToComparable 
) { 
    using (var e = source.GetEnumerator()) { 
     if (!e.MoveNext()) { 
      throw new InvalidOperationException("Sequence is empty."); 
     } 
     TSource max = e.Current; 
     IComparable maxProjection = projectionToComparable(e.Current); 
     while (e.MoveNext()) { 
      IComparable currentProjection = projectionToComparable(e.Current); 
      if (currentProjection.CompareTo(maxProjection) > 0) { 
       max = e.Current; 
       maxProjection = currentProjection; 
      } 
     } 
     return max;     
    } 
} 

Answer 7

A O más simple (n) solución:

var groups = words.GroupBy(x => x); 
var max = groups.Max(x => x.Count()); 
var top = groups.First(y => y.Count() == max).Key; 

Answer 8

Aquí está una junta muy rápida solución (n) en una línea (!):

s.GroupBy(x => x).Aggregate((IGrouping<string,string>)null, (x, y) => (x != null && y != null && x.Count() >= y.Count()) || y == null ? x : y, x => x); 

O esto:

s.GroupBy(x => x).Select(x => new { Key = x.Key, Count = x.Count() }).Aggregate(new { Key = "", Count = 0 }, (x, y) => x.Count >= y.Count ? x : y, x => x);