Encuentra el número que ocurre más en una lista <int>

Question

¿Existe alguna manera rápida y agradable de utilizar linq?

Answer 1

¿Qué tal:

var most = list.GroupBy(i=>i).OrderByDescending(grp=>grp.Count()) 
     .Select(grp=>grp.Key).First(); 

o en la sintaxis de consulta:

var most = (from i in list 
      group i by i into grp 
      orderby grp.Count() descending 
      select grp.Key).First(); 

Por supuesto, si va a utilizar esto en varias ocasiones, se podría añadir un método de extensión:

public static T MostCommon<T>(this IEnumerable<T> list) 
{ 
    return ... // previous code 
} 

Entonces puede usar:

var most = list.MostCommon(); 

Answer 2

No está seguro acerca de las expresiones lambda, pero me

1. Ordenar la lista [O (n log n)]

2. Busque en la lista [O (n)] encontrar la pista más larga -longitud.

3. Escanear de nuevo [O (n)] informando cada número que tenga esa longitud de ejecución.

Esto se debe a que podría haber más de un número que se produce con mayor frecuencia.

Answer 3

Alguien pidió una solución donde hay vínculos. Aquí está una puñalada en la que:

int indicator = 0 

var result = 
    list.GroupBy(i => i) 
    .Select(g => new {i = g.Key, count = g.Count()} 
    .OrderByDescending(x => x.count) 
    .TakeWhile(x => 
    { 
     if (x.count == indicator || indicator == 0) 
     { 
     indicator = x.count; 
     return true; 
     } 
     return false; 
    }) 
    .Select(x => x.i); 

Answer 4

Tomado de mi respuesta here:

public static IEnumerable<T> Mode<T>(this IEnumerable<T> input) 
{    
    var dict = input.ToLookup(x => x); 
    if (dict.Count == 0) 
     return Enumerable.Empty<T>(); 
    var maxCount = dict.Max(x => x.Count()); 
    return dict.Where(x => x.Count() == maxCount).Select(x => x.Key); 
} 

var modes = { }.Mode().ToArray(); //returns { } 
var modes = { 1, 2, 3 }.Mode().ToArray(); //returns { 1, 2, 3 } 
var modes = { 1, 1, 2, 3 }.Mode().ToArray(); //returns { 1 } 
var modes = { 1, 2, 3, 1, 2 }.Mode().ToArray(); //returns { 1, 2 } 

yo fuimos para una prueba de rendimiento entre el enfoque de arriba y David B'sTakeWhile.

fuente = {}, iteraciones = 1000000
mío - 300 ms, el David de - 930 ms

fuente = {1}, iteraciones = 1000000
minas - 1070 ms, el David de - 1560 ms

fuente = 100 + INT con 2 duplicados, iteraciones = 10000
minas - 300 ms, el David de - 500 ms

fuente = 10000 ints aleatorios con aproximadamente 100 + d uplicates, iteraciones = 1000
minas - 1280 ms, de David - 1400 ms

Answer 5

Aquí hay otra respuesta, que parece ser rápida. Creo que Nawfal's answer es generalmente más rápido, pero esto podría sombrearlo en largas secuencias.

public static IEnumerable<T> Mode<T>(
    this IEnumerable<T> source, 
    IEqualityComparer<T> comparer = null) 
{ 
    var counts = source.GroupBy(t => t, comparer) 
     .Select(g => new { g.Key, Count = g.Count() }) 
     .ToList(); 

    if (counts.Count == 0) 
    { 
     return Enumerable.Empty<T>(); 
    } 

    var maxes = new List<int>(5); 
    int maxCount = 1; 

    for (var i = 0; i < counts.Count; i++) 
    { 
     if (counts[i].Count < maxCount) 
     { 
      continue; 
     } 

     if (counts[i].Count > maxCount) 
     { 
      maxes.Clear(); 
      maxCount = counts[i].Count; 
     } 

     maxes.Add(i); 
    } 

    return maxes.Select(i => counts[i].Key); 
}