Suchen Sie die am häufigsten vorkommende Nummer in einer List & lt; int & gt;

Gibt es eine schnelle und schöne Weise die Verwendung von linq?

InformationsquelleAutor der Frage | 2008-12-10

  1. 65

    Wie etwa:

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

    oder in der Abfrage-syntax:

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

    Natürlich, wenn du das wiederholt, könnte man hinzufügen, eine Erweiterung-Methode:

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

    Dann können Sie verwenden:

    var most = list.MostCommon();

    InformationsquelleAutor der Antwort Marc Gravell

  2. 4

    Nicht sicher über die lambda-Ausdrücke, aber ich würde

    1. Sortieren der Liste [O(n log n)]

    2. Scan in der Liste [O(n)] das finden der längsten run-length.

    3. Scannen Sie erneut [O(n)] reporting jede Zahl mit, dass der run-Länge.

    Dies ist, weil es könnte mehr als eine am meisten vorkommende Zahl.

    InformationsquelleAutor der Antwort Mike Dunlavey

  3. 2

    Genommen von meiner Antwort hier:

    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 }

    Ging ich für einen performance-test zwischen den obigen Ansatz und David B TakeWhile.

    source = { }, Iterationen = 1000000

    mine - 300 ms, David s - 930 ms

    source = { 1 }, Iterationen = 1000000

    mine - 1070 ms, David - 1560 ms

    Quelle = 100+ int-Werte mit 2 Duplikaten, Iterationen = 10000

    mine - 300 ms, David ' s - 500 ms

    source = 10000 zufällige int-Werte mit über 100+ - Duplikate, Iterationen = 1000

    mine - 1280 ms, David - 1400 ms

    InformationsquelleAutor der Antwort nawfal

  4. 1

    Hier ist eine weitere Antwort, die scheint zu sein, schnell. Ich denke, Nawfal Antwort ist in der Regel schneller, aber dies könnte Schatten, die es auf lange Sequenzen.

    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);
}

    InformationsquelleAutor der Antwort Jodrell

  5. 0

    Jemand nach einer Lösung gefragt, wo gibt es Krawatten. Hier ist ein stab bei, dass:

    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);

    InformationsquelleAutor der Antwort Amy B

Schreibe einen Kommentar