सूची में सबसे अधिक संख्या संख्या खोजें <int>

Question

क्या linq का उपयोग कर एक त्वरित और अच्छा तरीका है?

Answer 1

कैसे के बारे में:

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

या क्वेरी सिंटैक्स में:

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

:

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

बेशक

, अगर आप इस बार-बार प्रयोग करेंगे, तो आप एक विस्तार विधि जोड़ सकते हैं फिर आप इसका उपयोग कर सकते हैं:

var most = list.MostCommon(); 

Answer 2

लैम्ब्डा भाव के बारे में सुनिश्चित नहीं हैं, लेकिन मैं

1. क्रमबद्ध सूची जाएगा [O (n लॉग ऑन एन)]

2. सूची की जांच करके [हे (एन)] सबसे लंबे समय तक चलाने की खोज -length।

3. इसे फिर से स्कैन करें [ओ (एन)] उस रन-लंबाई वाले प्रत्येक नंबर की रिपोर्टिंग।

ऐसा इसलिए है क्योंकि एक से अधिक होने वाली संख्या हो सकती है।

Answer 3

किसी ने ऐसे समाधान के लिए कहा जहां संबंध हैं।

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

मेरा उत्तर 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 } 

मैं ऊपर दृष्टिकोण और David B'sTakeWhile के बीच एक प्रदर्शन परीक्षण के लिए चला गया।

स्रोत = {}, पुनरावृत्तियों = 1000000
मेरा - 300 एमएस, डेविड - 930 एमएस

स्रोत = {1}, पुनरावृत्तियों = 1000000
मेरा - 1070 एमएस, डेविड की - 1560 एमएस

स्रोत = 2 डुप्लिकेट, पुनरावृत्तियों = 10000
मेरा साथ 100 + ints - साथ 100 + के बारे में घ 500 एमएस

स्रोत = 10000 यादृच्छिक ints - 300 एमएस, डेविड uplicates, पुनरावृत्तियों = 1000
मेरा - 1280 एमएस, डेविड की - 1400 एमएस

Answer 5

यहाँ एक और सवाल का जवाब है, जो तेजी से हो रहा है है। मुझे लगता है कि Nawfal's answer आमतौर पर तेज़ है लेकिन यह लंबे अनुक्रमों पर इसे छाया कर सकता है।

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