Des tests répétés de caractères dans une chaîne

Si la chaîne est courte, alors juste les boucles et les tests pourrait bien être la plus simple et la plus efficace. Je veux dire que vous pourrait créer un hachage jeu (quelle que soit la plateforme que vous utilisez) et parcourir les personnages, à défaut, si le personnage est déjà dans le jeu et de l'ajouter à l'ensemble, d'ailleurs, mais c'est seulement susceptible de fournir toute prestation lorsque les chaînes sont plus.

EDIT: Maintenant que nous savons qu'il est trié, mquander réponse est le meilleur de l'OMI. Voici une mise en œuvre:

public static bool IsSortedNoRepeats(string text)
{
    if (text.Length == 0)
    {
        return true;
    }
    char current = text[0];
    for (int i=1; i < text.Length; i++)
    {
        char next = text[i];
        if (next <= current)
        {
            return false;
        }
        current = next;
    }
    return true;
}

Une courte alternative si vous n'avez pas l'esprit en répétant l'indexeur utilisation:

public static bool IsSortedNoRepeats(string text)
{
    for (int i=1; i < text.Length; i++)
    {
        if (text[i] <= text[i-1])
        {
            return false;
        }
    }
    return true;
}

EDIT: Bon, avec la "fréquence" de côté, je vais tourner le problème ronde un peu. Je vais quand même à supposer que la chaîne est triée, de sorte que ce que nous voulons savoir, c'est la longueur du plus long terme. Quand il n'y a pas de répétitions, la plus longue longueur sera de 0 (pour une chaîne vide) ou 1 (pour une chaîne non vide). Sinon, ça va être 2 ou plus.

D'abord une chaîne de caractères spécifique à la version:

public static int LongestRun(string text)
{
    if (text.Length == 0)
    {
        return 0;
    }
    char current = text[0];
    int currentRun = 1;
    int bestRun = 0;

    for (int i=1; i < text.Length; i++)
    {
        if (current != text[i])
        {
            bestRun = Math.Max(currentRun, bestRun);
            currentRun = 0;
            current = text[i];
        }
        currentRun++;
    }
    //It's possible that the final run is the best one
    return Math.Max(currentRun, bestRun);
}

Maintenant, nous pouvons aussi le faire comme une extension générale de la méthode sur IEnumerable<T>:

public static int LongestRun(this IEnumerable<T> source)
{
    bool first = true;
    T current = default(T);
    int currentRun = 0;
    int bestRun = 0;

    foreach (T element in source)
    {
        if (first || !EqualityComparer<T>.Default(element, current))
        {
            first = false;
            bestRun = Math.Max(currentRun, bestRun);
            currentRun = 0;
            current = element;
        }
    }
    //It's possible that the final run is the best one
    return Math.Max(currentRun, bestRun);
}

Ensuite, vous pouvez appeler "AABCD".LongestRun() par exemple.

OriginalL'auteur Jon Skeet

Cela va vous dire très rapidement si une chaîne contient des doublons:

bool containsDups = "ABCDEA".Length != s.Distinct().Count();

Il vérifie juste le nombre de caractères distincts à l'encontre de la longueur d'origine. Si ils sont différents, vous avez des doublons...

Edit: je suppose que cela ne prend pas soin de la fréquence de dup vous avez noté dans votre modifier si... mais quelques autres suggestions ici déjà prendre soin de cela, donc je ne vais pas poster le code que je note un certain nombre d'entre eux vous donnent déjà une assez élégant. J'aime particulièrement Joe est mise en œuvre à l'aide de LINQ extensions.

OriginalL'auteur BenAlabaster

Je pense que la façon la plus simple d'y parvenir est d'utiliser cette simple regex

bool foundMatch = false;
foundMatch = Regex.IsMatch(yourString, @"(\w)");

Si vous avez besoin de plus d'informations sur le match (début, durée, etc)

        Match match = null;
    string testString = "ABCDE AABCD";
    match = Regex.Match(testString, @"(\w)+?");
    if (match.Success)
    {
        string matchText = match.Value; //AA
        int matchIndnex = match.Index;  //6
        int matchLength = match.Length; //2
    }

OriginalL'auteur xrost

Comment au sujet de quelque chose comme:

string strString = "AA BRA KA DABRA";

var grp = from c in strString.ToCharArray() 
        group c by c into m
        select new { Key = m.Key, Count = m.Count() };

foreach (var item in grp)
{
    Console.WriteLine(
        string.Format("Character:{0} Appears {1} times", 
        item.Key.ToString(), item.Count));
}

OriginalL'auteur CasperT

J'ai commencé à chercher des infos sur le net et je suis arrivé à la solution suivante.

string input = "aaaaabbcbbbcccddefgg";
        char[] chars = input.ToCharArray();
        Dictionary<char, int> dictionary = new Dictionary<char,int>();

        foreach (char c in chars)
        {
            if (!dictionary.ContainsKey(c))
            {
                dictionary[c] = 1; //
            }
            else
            {
                dictionary[c]++;
            }
        }

        foreach (KeyValuePair<char, int> combo in dictionary)
        {
            if (combo.Value > 1) //If the vale of the key is greater than 1 it means the letter is repeated
            {
                Console.WriteLine("Letter " + combo.Key + " " + "is repeated " + combo.Value.ToString() + " times");
            }

        }

J'espère que cela aide, j'ai eu un entretien d'embauche dans lequel l'enquêteur m'a demandé de résoudre cela et je comprends qu'il s'agit d'une question commune.

OriginalL'auteur BlackPauler

Le hachage solution Jon a été décrit est probablement le meilleur. Vous pouvez utiliser un HybridDictionary depuis qui fonctionne bien avec de petits et de grands ensembles de données. Lorsque la lettre est la clé et la valeur de la fréquence. (Mise à jour de la fréquence à chaque fois que l'ajout d'échec ou de la HybridDictionary renvoie la valeur true .Contient(key))

OriginalL'auteur Paul U