我必須計算給定單詞中有多少字謎。我嘗試過使用階乘、排列并使用單詞中每個字母的可能性。這就是我所做的。

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

示例：對于 aabv，我必須得到 12；對于aaab，我必須得到4

uj5u.com熱心網友回復：

如評論中所述，有一個計算不同字謎數量的公式

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

其中n是單詞的長度，k是不同字符c_i的數量，是特定字符出現頻率的計數。

所以首先，你需要計算教員

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

你還需要計算單詞中的字符

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

那么字謎計數可以計算如下

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

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

  return ac;
}

uj5u.com熱心網友回復：

用代碼回答

這是用 c# 撰寫的，因此它可能不適用于您想要的語言，但您沒有指定語言。

這通過獲取字串的所有可能排列，將串列中找到的每個副本添加到另一個串列，然后從原始串列中洗掉這些副本來作業。之后，原始串列的計數是字串包含的唯一字謎的數量。

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

最后的筆記

我知道這不是最干凈，也不是最好的解決方案。這只是我所知道的 3 種面向物件語言中最好的一種，這也不是一個太復雜的解決方案。易于理解，易于更改語言，所以這是我決定給出的答案。

編輯

這是基于此答案的評論的新答案。

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

標籤：功能 循环 字谜

上一篇：創建一個二變數函式的影像并在R中找到它的最優值

下一篇：使用計算創建一個熊貓值列，但每隔x次將計算更改為不同的計算