Question

我必须在C＃中编写一个程序来检查给定字典中哪些单词是彼此的字谜。

程序必须采用这一系列的单词{map, art, tar, pam, why} 输出应为map, pam, art, tar。

Answer 1

using System;

namespace Anagram_Test
{
    class ClassCheckAnagram
    {
        public int check_anagram(char[] a, char[] b)
        {
            Int16[] first = new Int16[26];
            Int16[] second = new Int16[26];
            int c = 0;

            for (c = 0; c < a.Length; c++)
            {
                first[a[c] - 'a']++;
            }

            c = 0;

            for (c=0; c<b.Length; c++)
            {
                second[b[c] - 'a']++;
               
            }

            for (c = 0; c < 26; c++)
            {
                if (first[c] != second[c])
                    return 0;
            }

            return 1;
        }
    }
}

using System;

namespace Anagram_Test
{
    class Program
    {
        static void Main(string[] args)
        {

            ClassCheckAnagram cca = new ClassCheckAnagram();
            Console.WriteLine("Enter first string\n");
            string aa = Console.ReadLine();
            char[] a = aa.ToCharArray();

            Console.WriteLine("\nEnter second string\n");
            string bb = Console.ReadLine();
            char[] b = bb.ToCharArray();
            int flag = cca.check_anagram(a, b);

            if (flag == 1)
                Console.WriteLine("\nThey are anagrams.\n");
            else
                Console.WriteLine("\nThey are not anagrams.\n");
            Console.ReadKey();
        }

    }
}

此程序显示如何在CSharp语言中检查两个给定的输入字符串是否为Anagrams。字谜是两个不同的单词或字符组合，它们具有相同的字母和数字。因此，一组特定的字母表可以创建Anagrams的许多排列。换句话说，如果我们在两个单词（字符串）中有相同的字符集，那么它们就是Anagrams。

我们创建一个输入作为字符数组输入对的函数。当我们得到两组不同的字符时，我们检查这两组中每个字母的数量。最后，我们计算并检查这些集合中每个字母表的字符数值是否相同。如果两个字符集中的所有字符都以相同的速率出现，那么我们将集合声明为Anagrams，否则不是。

Answer 2

检查以下脚本。

        var inputArr = new string[]{"mapa","art","tra","pam","why"};
        var outputList = new List<string>();
        for (int i = 0; i < inputArr.Length; i++)
        {
            for (int j = i+1; j<inputArr.Length ; j++)
            {                    
                char[] temp1 = inputArr[i].ToLower().ToCharArray();
                char[] temp2 = inputArr[j].ToLower().ToCharArray();
                if (temp1.Length != temp2.Length)
                    continue;
                else
                {
                    bool isAnnograms = true;
                    for (int k1 = 0, k2=temp1.Length-1; k1 < temp1.Length; k1++,k2--)
                    {
                        if (temp1[k1] == temp2[k2])
                            continue;
                        else
                            isAnnograms = false;
                    }
                    if (isAnnograms)
                    {
                        outputList.Add(new string(temp1));
                        outputList.Add(new string(temp2));
                        isAnnograms = false;
                    }
                }
            }
        }

outputList显示Anagram列表

Answer 3

我认为你可能会发现MSDN中给出的this example非常有用：它是一个适应性强的LINQ解决方案。

Answer 4

如果Word具有某些字母的相同数字，则它是彼此的字谜。您可以创建char-＆gt; int的地图并计算字母数，然后比较两个地图。如果它们具有相同的元素，那么这两个词就是字谜。

或者：

按字母顺序对每个单词中的字符（到临时变量）进行排序，然后比较你得到的内容。

对于家庭作业，创建BOTH算法！

：）

Answer 5

另一种方法是计算排序。

给出两个字符串：

foo和oof。对于第一个字符串：

Dictionary<char, int> occurences = new Dictionary<char, int>();

foreach(var c in firstString){

   int result;
   if(occurences.tryGetValue(c, out result)){
     result++;
   }
   else
   {
     occurences.Add(c,0);
   }

}

现在你建立你的计数。然后你可以迭代另一个字符串并从每次出现时减少。最后，你应该让你的字典元素的值为0.如果一个键不在字典中，你就会失败。

Answer 6

    /// <summary>
    /// This solutions works for all unicode string values.
    /// </summary>
    /// <remarks>2n time complexity. Dictionary insertion and retrieval will be minimal</remarks>
    public static bool Anagram(string valueA, string valueB)
    {
        if (string.IsNullOrWhiteSpace(valueA) || string.IsNullOrWhiteSpace(valueB))
        {
            return false;
        }

        if (valueA.Length != valueB.Length)
        {
            return false;
        }

        if (valueA.Equals(valueB))
        {
            return false;
        }

        var values = new Dictionary<char, int>();
        foreach (char key in valueA)
        {
            if (!values.ContainsKey(key))
            {
                values[key] = 1;
            }
            else
            {
                values[key] += 1;
            }
        }

        var uniqueCharacters = values.Keys.Count;
        for (var i = 0; i < valueB.Length; i++)
        {
            char item = valueB[i];
            if (!values.ContainsKey(item) || values[item] == 0)
            {
                return false; // too many occurances of char found
            }

            values[item] -= 1;
            if (values[item] == 0)
            {
                uniqueCharacters -= 1;

                if (uniqueCharacters == 0)
                {
                    return i == valueB.Length - 1;
                }
            }
        }

        return false;
    }

        [Test]
        public void Anagram3Test()
        {
            Assert.That(Anagram3(null, null), Is.False);
            Assert.That(Anagram3(string.Empty, null), Is.False);
            Assert.That(Anagram3("a", null), Is.False);

            Assert.That(Anagram3("ab", "ab"), Is.False);
            Assert.That(Anagram3("carthorses", "orchestra"), Is.False);
            Assert.That(Anagram3("orchestra", "carthorses"), Is.False);
            Assert.That(Anagram3("abc", "bce"), Is.False);

            Assert.That(Anagram3("orchestra", "carthorse"), Is.True);
        }

Answer 7

我最近在一次采访中得到了一个类似的问题，并认为我在这里抛出我的解决方案。此方法适用于Unicode字符，并且不区分大小写。它没有直接回答你的问题，但可以用来验证数组中的两个字符串是否为字谜。

    private static bool IsAnagram(String s1, String s2)
    {
        if (String.IsNullOrEmpty(s1)) throw new ArgumentNullException("s1");
        if (String.IsNullOrEmpty(s2)) throw new ArgumentNullException("s2");

        Dictionary<char, int> m1 = new Dictionary<char, int>();
        Dictionary<char, int> m2 = new Dictionary<char, int>();

        // get the length of the longer string, this is used for the for loop below
        int length = s1.Length > s2.Length ? s1.Length : s2.Length;

        // iterate through both strings at the same time
        // verifies that the index is not out of bounds before checking if the current character is a letter
        // adds character to dictionary if it doesn't exist and increments count
        for (int i = 0; i < length; i++)
        {
            if (i < s1.Length && Char.IsLetter(s1[i]))
            {
                if (!m1.ContainsKey(char.ToLower(s1[i])) m1.Add(char.ToLower(s1[i]), 0);

                m1[char.ToLower(s1[i])]++;
            }

            if (i < s2.Length && Char.IsLetter(s2[i]))
            {
                if (!m2.ContainsKey(char.ToLower(s2[i]) m2.Add(char.ToLower(s2[i]), 0);

                m2[char.ToLower(s2[i])]++;
            }
        }

        // if the two dictionaries don't match in length bail out now
        if (m1.Count != m2.Count) return false;

        // uses first dictionary to verify key and value exist in second dictionary
        foreach (char current in m1.Keys)
        {
            if (!m2.ContainsKey(current)) return false;
            if (m1[current] != m2[current]) return false;
        }

        return true;
    }

Answer 8

public static bool AreStringsAnagrams(string a, string b)
    {
        if (string.IsNullOrWhiteSpace(a) || string.IsNullOrWhiteSpace(b) || a.Length != b.Length)
        {
            return false;
        }

        a = a.ToLower();
        b = b.ToLower();

        if (a.Equals(b))
            return false;

        char[] ac = a.ToCharArray();
        char[] bc = b.ToCharArray();
        Array.Sort(ac);
        Array.Sort(bc);
        for (int i = 0; i < ac.Length; i++)
        {
            if (ac[i] != bc[i])
            {
                return false;
            }
        }

        return true;
    }

如何检查哪些单词是彼此的字谜？

8 个答案: