Comment pouvez vérifier l'anagramme de chaînes de caractères en C#

Est-ce la solution?

string a = "abcd";
string b = "bcda"; //bad daa a1b2c3 abc123

string aa = String.Concat(a.OrderBy(c => c));
string bb = String.Concat(b.OrderBy(c => c));

if (aa == bb)
{
     Console.WriteLine("YES");
}
else
{
     Console.WriteLine("NO");
}

ou plus courte

if (String.Concat(a.OrderBy(c => c)).Equals(String.Concat(b.OrderBy(c => c))) ...

OriginalL'auteur Thomas Krojer

Il y a la voie rapide et de la manière la plus simple:

void Test()
{
    string a = "abccabccabccabccabccabccabccabccabccabccabccabccabccabccabccabcc";
    string b = "bcacbcacbcacbcacbcacbcacbcacbcacbcacbcacbcacbcacbcacbcacbcacbcac";

    IsAnagramSimple(a, b);
    IsAnagramFast(a, b);
}


private bool IsAnagramSimple(string a, string b)
{
    return a.OrderBy(c => c).SequenceEqual(b.OrderBy(c => c));
}

private bool IsAnagramFast(string a, string b)
{
    if (a.Length != b.Length)
    {
        return false;
    }

    var aFrequency = CalculateFrequency(a);
    var bFrequency = CalculateFrequency(b);

    foreach (var key in aFrequency.Keys)
    {
        if (!bFrequency.ContainsKey(key)) return false;
        if (aFrequency[key] != bFrequency[key]) return false;
    }

    return true;
}

private Dictionary<char, int> CalculateFrequency(string input)
{
    var frequency = new Dictionary<char, int>();
    foreach (var c in input)
    {
        if (!frequency.ContainsKey(c))
        {
            frequency.Add(c, 0);
        }
        ++frequency[c];
    }
    return frequency;
}

OriginalL'auteur Kvam

Une autre façon est de vérifier si la première contient un char à l'intérieur de la deuxième. retirez ensuite que le char de la première jusqu'à ce que pas plus de caractères à gauche.

    private bool IsAnagram(string a, string b)
{
if (a.Length != b.Length) return false;
List<char> list1 = a.ToList();
List<char> list2 = b.ToList();
for (int i = 0; i < a.Length; i++)
{
//try to remove list 1 item from list 2
//if didn't find any thing to remove. so they are not anagram
if (!list2.Remove(list1[i])) return false;
}
return true; //loop finished successfully. they are anagram
}

Noter que le List<T>.Remove() méthode qui retourne une valeur booléenne qui spécifie si la méthode a été en mesure de supprimer quoi que ce soit ou pas.

Vous pouvez faire tout cela en une seule ligne de Linq.

List<char> list = "god".ToList();
bool isAnagram = "dog".All(ch => list.Remove(ch));

La méthode Linq All<char>(Func<char,bool>) va effectuer le délégué jusqu'à ce que le Func<char,bool> retourne la valeur false ou jusqu'à la fin de la requête. si la touche Func return false alors All retourne false trop. sinon, il retournera true.

OriginalL'auteur M.kazem Akhgary

Cette solution permettra de vérifier anagramme pour exactement 1 pass (O(Cn) où C = 1)

    public static bool IsAnagram(string s1, string s2) {
if (s1.Length != s2.Length)
return false;
int i = -1;
var chars = new Dictionary<char, int> ();
Func <char, int, int, int> updateCount = (c, side, pdiff) => {
int count = 0;
chars.TryGetValue (c, out count);
var newCount = count + side;
chars[c] = newCount;
if (count == 0)
return pdiff + 1;
else if (newCount == 0)
return pdiff - 1;
else
return pdiff;
};
int diff = 0;
foreach (var c1 in s1) {
i++;
var c2 = s2 [i];
if (c1 == c2)
continue;
diff = updateCount(c1, 1, diff);
diff = updateCount(c2, -1, diff);
}
return diff == 0;
}
public static void Main (string[] args)
{
string s1 = "asd";
string s2 = "ads";
Console.WriteLine (IsAnagram(s1, s2));
}

OriginalL'auteur Andrey

Si vous avez une contrainte de temps limitée, c'est mieux/solution efficace:

bool CheckAnagram(string str1, string str2)
{
if(str1.Length != str2.Length)
return false;
if(str1 == str2)
return true;
//based on 128 ASCII characeters. 
//You can change the paramter depending on requirement
int charLength = 128; 
int[] counter = new int[charLength];
for(int i=0; i<str1.Length; i++)
{
counter[str1[i]-'a']++;
counter[str2[i]-'a']--;
}
for (int c = 0; c < charLength; c++) 
{
if(counter[c] != 0) return false;
}
return true;
}

OriginalL'auteur Umair M