Trouvez le caractère avec la plupart des occurrences dans la chaîne avec C #?

input.GroupBy(x => x).OrderByDescending(x => x.Count()).First().Key

Notes:

• si vous en avez besoin pour travailler sur ancienne (2.0) versions de .Net envisager LinqBridge. Si vous ne pouvez pas utiliser le C# 3.0 (ciblage .Net 2.0) vous avez probablement mieux avec d'autres solutions, en raison du manque de soutien de lambda. L'autre .Net 2.0+ option est couvert dans xanatos répondre.
• pour le cas de "aaaabbbb" un seul de ceux-ci seront retournés (merci xanatos pour un commentaire. Si vous avez besoin de tous les éléments avec un maximum de compter, utiliser Albin de la solution à la place.
• en raison de tri des si O(n log n) solution. Si vous avez besoin de mieux - trouver la valeur Max. par recherche linéaire plutôt que de les trier d'abord qui va donner de O(n). Voir LINQ: Comment effectuer .Max() sur une propriété de tous les objets de la collection et de retour de l'objet avec une valeur maximale

string testString = "abbbbccd";
var charGroups = (from c in testString
                    group c by c into g
                    select new
                    {
                        c = g.Key,
                        count = g.Count(),
                    }).OrderByDescending(c => c.count);
foreach (var group in charGroups)
{
    Console.WriteLine(group.c + ": " + group.count);
}

MODIFIER 3

Voici ma dernière réponse qui, je pense (juste) des nuances Nawfal est pour les performances sur des séquences plus longues.

Toutefois, compte tenu de la réduction de la complexité des Nawfal réponseet de ses plus universel des performances, en particulier en ce qui concerne la question, j'avais le choix.

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

---

EDIT 2

---

MODIFIER

---

---

Si vous voulez un efficace solution générique, qui explique le fait que plusieurs éléments pourraient avoir la même fréquence, commencer avec cette extension,

IOrderedEnumerable<KeyValuePair<int, IEnumerable<T>>>Frequency<T>(
    this IEnumerable<T> source,
    IComparer<T> comparer = null)
{
    return source.GroupBy(t => t, comparer)
        .GroupBy(
            g => g.Count(),
            (k, s) => new KeyValuePair<int, IEnumerable<T>>(
                k,
                s.Select(g => g.First())))
        .OrderByDescending(f => f.Key);
}

Cette extension fonctionne dans tous les scénarios suivants

var mostFrequent = string.Empty.Frequency().FirstOrDefault();

var mostFrequent = "abbbbccd".Frequency().First();

ou,

var mostFrequent = "aaacbbbcdddceee".Frequency().First();

Noter que mostFrequent est un KeyValuePair<int, IEnumerable<char>>.

---

Si donc l'esprit que vous pouvez simplifier ce à un autre poste,

public static IEnumerable<T> Mode<T>(
    this IEnumerable<T> source,
    IEqualityComparer<T> comparer = null)
{
    var mode = source.GroupBy(
            t => t,
            (t, s) => new { Value = t, Count = s.Count() }, comparer)
        .GroupBy(f => f.Count)
        .OrderbyDescending(g => g.Key).FirstOrDefault();

    return mode == null ? Enumerable.Empty<T>() : mode.Select(g => g.Value);
}

qui, évidemment, peut être utilisé ainsi,

var mostFrequent = string.Empty.Mode();

var mostFrequent = "abbbbccd".Mode();

var mostFrequent = "aaacbbbcdddceee".Mode();

ici, mostFrequent est un IEnumerable<char>.

C'est Femaref la solution modifié pour renvoyer plusieurs lettres si leur nombre de matches. Il n'est plus un one-liner, mais encore assez concis.

var groups = "aaaabbbbccd".GroupBy(x => x).Select(x => new { Letter = x.Key, Count = x.Count() }).ToList();
return groups.Where(g => g.Count == groups.Max(g2 => g2.Count)).Select(g => g.Letter);

Après discussion avec nawfal:

void Main()
{
    "aaaabbhbbxh".GetMostFrequentCharacters().Dump();
    ((string)null).GetMostFrequentCharacters().Dump();
    "  ".GetMostFrequentCharacters().Dump();
    "".GetMostFrequentCharacters().Dump();    
}

static class LinqPadExtensions {
    public static IEnumerable<char> GetMostFrequentCharacters(this string str) {
        if (string.IsNullOrEmpty(str))
            return Enumerable.Empty<char>();

        var groups = str.GroupBy(x => x).Select(x => new { Letter = x.Key, Count = x.Count() }).ToList();
        var max = groups.Max(g2 => g2.Count);
        return groups.Where(g => g.Count == max).Select(g => g.Letter);
    }
}

        //find most occuring character and count from below string

        string totest = "abcda12Zernn111y";

        string maxOccuringCharacter = "";
        int maxOccurence = 0;string currentLoopCharacter = ""; string updatedStringToTest = "";int cnt = 0;

        for (int i = 0; i < totest.Length; i++)
        {
            currentLoopCharacter = totest[i].ToString();
            updatedStringToTest = totest.Replace(currentLoopCharacter, "");

            cnt = totest.Length - updatedStringToTest.Length;

            if (cnt > maxOccurence)
            {
                maxOccuringCharacter = currentLoopCharacter;
                maxOccurence = cnt;
            }

            totest = updatedStringToTest;
        }

        Console.WriteLine("The most occuring character is {0} and occurence was {1}", maxOccuringCharacter, maxOccurence.ToString());
        Console.ReadLine();