I have to calculate how many anagrams are in a given word. I have tried using factorial, permutations and using the posibilities for each letter in the word. This is what I have done.

static int DoAnagrams(string a, int x)
{
    int anagrams = 1;
    int result = 0;
    x = a.Length;
    for (int i = 0; i < x; i  )
    { anagrams *= (x - 1); result  = anagrams; anagrams = 1; }
    return result;
}

Example: for aabv I have to get 12; for aaab I have to get 4

CodePudding user response：

As already stated in a comment there is a formula for calculating the number of different anagrams

 #anagrams = n! / (c_1! * c_2! * ... * c_k!)

where n is the length of the word, k is the number of distinct characters and c_i is the count of how often a specific character occurs.

So first of all, you will need to calculate the faculty

int fac(int n) {
  int f = 1;
  for (int i = 2; i <=n; i  ) f*=i;
  return f;
}

and you will also need to count the characters in the word

Dictionary<char, int> countChars(string word){
  var r = new Dictionary<char, int>();
  foreach (char c in word) {
    if (!r.ContainsKey(c)) r[c] = 0;
    r[c]  ;
  }
  return r;
}

Then the anagram count can be calculated as follows

int anagrams(string word) {
  int ac = fac(word.Length);
  var cc = countChars(word);

  foreach (int ct in cc.Values)
    ac /= fac(ct);

  return ac;
}

CodePudding user response：

Answer with Code

This is written in c#, so it may not apply to the language you desire, but you didn't specify a language.

This works by getting every possible permutation of the string, adding every copy found in the list to another list, then removing those copies from the original list. After that, the count of the original list is the amount of unique anagrams a string contains.

        private static List<string> anagrams = new List<string>();

        static void Main(string[] args)
        {
            string str = "AAAB";

            char[] charArry = str.ToCharArray();
            Permute(charArry, 0, str.Count() - 1);

            List<string> copyList = new List<string>();

            for(int i = 0; i < anagrams.Count - 1; i  )
            {
                List<string> anagramSublist = anagrams.GetRange(i   1, anagrams.Count - 1 - i);
                var perm = anagrams.ElementAt(i);

                if (anagramSublist.Contains(perm))
                {
                    copyList.Add(perm);
                }
            }

            foreach(var copy in copyList)
            {
                anagrams.Remove(copy);
            }

            Console.WriteLine(anagrams.Count);
            Console.ReadKey();
        }

        static void Permute(char[] arry, int i, int n)
        {
            int j;
            if (i == n)
            {
                var temp = string.Empty;
                foreach(var character in arry)
                {
                    temp  = character;
                }
                anagrams.Add(temp);
            }
                
            else
            {
                for (j = i; j <= n; j  )
                {
                    Swap(ref arry[i], ref arry[j]);
                    Permute(arry, i   1, n);
                    Swap(ref arry[i], ref arry[j]); //backtrack
                }
            }
        }

        static void Swap(ref char a, ref char b)
        {
            char tmp;
            tmp = a;
            a = b;
            b = tmp;
        }

Final Notes

I know this isn't the cleanest, nor best solution. This is simply one that carries the best across the 3 object oriented languages I know, that's also not too complex of a solution. Simple to understand, simple to change languages, so it's the answer I've decided to give.

EDIT

Here's the a new answer based on the comments of this answer.

        static void Main(string[] args)
        {
            var str = "abaa";
            var strAsArray = new string(str.ToCharArray());
            var duplicateCount = 0;
            List<char> dupedCharacters = new List<char>();

            foreach(var character in strAsArray)
            {
                if(str.Count(f => (f == character)) > 1 && !dupedCharacters.Contains(character))
                {
                    duplicateCount  = str.Count(f => (f == character));
                    dupedCharacters.Add(character);
                }
            }
            
            Console.WriteLine("The number of possible anagrams is: "   (factorial(str.Count()) / factorial(duplicateCount)));
            Console.ReadLine();

            int factorial(int num)
            {
                if(num <= 1)
                    return 1;

                return num * factorial(num - 1);
            }
        }