Question

这是我的代码，用于确定两个字符串是否为字谜

static boolean isAnagram(String a, String b) {
    if (a.length() != b.length()) return false;
    a = a.toLowerCase();
    b = b.toLowerCase();
    int m1=0;
    for(int i=0;i<a.length();i++){
        m1 += (int)a.charAt(i);
        m1 -= (int)b.charAt(i);

    }
        return m1==0;
}

我的代码在两个测试用例中失败

情况1：String a="xyzw";和String b="xyxy";
情况2：String a="bbcc";和String b="dabc";

有人能帮助我通过上述两个案件吗？

Answer 1

我认为您的代码不起作用，因为您将字符代码汇总起来，但是答案可能为零，但它们不相等，例如：“ ad”“ bc”
更好的方法是对字符串中的字符进行排序，如果它们具有相同的数组长度和相同的顺序，那么两个字符串就是字谜。

static boolean isAnagram(String str1, String str2) {
    int[] str1Chars = str1.toLowerCase().chars().sorted().toArray();
    int[] str2Chars = str2.toLowerCase().chars().sorted().toArray();
    return Arrays.equals(str1Chars, str2Chars);
}

希望对您有所帮助。（这有点困难，因为我使用流来创建和排序字符数组）

Answer 2

尝试一下：

import java.io.*; 

class GFG{ 

    /* function to check whether two strings are  
    anagram of each other */
    static boolean areAnagram(char[] str1, char[] str2) 
    { 
        // Get lenghts of both strings 
        int n1 = str1.length; 
        int n2 = str2.length; 

        // If length of both strings is not same, 
        // then they cannot be anagram 
        if (n1 != n2) 
            return false; 

        // Sort both strings 
        quickSort(str1, 0, n1 - 1); 
        quickSort(str2, 0, n2 - 1); 

        // Compare sorted strings 
        for (int i = 0; i < n1;  i++) 
            if (str1[i] != str2[i]) 
                return false; 

        return true; 
    } 

    // Following functions (exchange and partition  
    // are needed for quickSort) 
    static void exchange(char A[],int a, int b) 
    { 
        char temp; 
        temp = A[a]; 
        A[a]   = A[b]; 
        A[b]   = temp; 
    } 

    static int partition(char A[], int si, int ei) 
    { 
        char x = A[ei]; 
        int i = (si - 1); 
        int j; 

        for (j = si; j <= ei - 1; j++) 
        { 
            if(A[j] <= x) 
            { 
                i++; 
                exchange(A, i, j); 
            } 
        } 
        exchange (A, i+1 , ei); 
        return (i + 1); 
    } 

    /* Implementation of Quick Sort 
    A[] --> Array to be sorted 
    si  --> Starting index 
    ei  --> Ending index 
    */
    static void quickSort(char A[], int si, int ei) 
    { 
        int pi;    /* Partitioning index */
        if(si < ei) 
        { 
            pi = partition(A, si, ei); 
            quickSort(A, si, pi - 1); 
            quickSort(A, pi + 1, ei); 
        } 
    } 

    /* Driver program to test to print printDups*/
    public static void main(String args[]) 
    { 
        char str1[] = {'t','e','s','t'}; 
        char str2[] = {'t','t','e','w'}; 
        if (areAnagram(str1, str2)) 
            System.out.println("The two strings are"+ 
                             " anagram of each other"); 
        else
            System.out.println("The two strings are not"+ 
                               " anagram of each other"); 
    } 
}

Answer 3

static boolean isAnagram(String a, String b) {
        if (a.length() != b.length())
            return false;
        a = a.toLowerCase();
        b = b.toLowerCase();
        HashMap<Integer, Integer> m1 = new HashMap<>(); // Key is ascii number, Value is count. For String a
        HashMap<Integer, Integer> m2 = new HashMap<>(); // Key is ascii number, Value is count. For String b
        for (int i = 0; i < a.length(); i++) {
            int an = (int) (a.charAt(i));
            int bn = (int) (b.charAt(i));
            // Add 1 to current ascii number. String a.
            if (m1.containsKey(an)) {
                m1.put(an, m1.get(an) + 1);
            }else {
                m1.put(an, 1);
            }
            // Add 1 to current ascii number. String b.
            if (m2.containsKey(bn)) {
                m2.put(bn, m2.get(bn) + 1);
            }else {
                m2.put(bn, 1);
            }
        }

        //Check both count equals().
        return m1.equals(m2);
    }

您应该检查每个字母。如果（a [0]的ascii == b [0]的ascii + 1）和（a [1]的ascii == b [1]-1的ascii），则它将返回true，因为1-1为零。很抱歉，代码非常复杂。

Answer 4

实现不正确。虽然一对字谜总是具有相同的长度和相同的字符数，但这不是一个充分的条件。有许多对字符串，它们具有相同的长度和相同的字符总和，而不是字谜。例如"ad"和"bc"。

更好的实现是对每个字符出现在每个字符串中的次数进行计数并进行比较。例如：

public static boolean isAnagram(String a, String b) {
    return charCounts(a).equals(charCounts(b));
}

private static Map<Integer, Long> charCounts(String s) {
    return s.chars()
            .boxed()
            .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
}

Answer 5

添加字符值是容易出错的逻辑，因为A+C和B+B生成相同的数字。在这种情况下，最好的选择是使用数组。查看下面的代码-

static boolean isAnagram(String a, String b) {
    if (a.length() != b.length()) return false;
    a = a.toLowerCase();
    b = b.toLowerCase();

    char[] charA = a.toCharArray();
    Arrays.sort(charA);

    char[] charB = b.toCharArray();
    Arrays.sort(charB);

    return Arrays.equals(charA, charB);
}

这应该给您您想要的东西。

Answer 6

查看以下方法：

/**
 * Java program - String Anagram Example.
 * This program checks if two Strings are anagrams or not
 */
public class AnagramCheck {

/*
 * One way to find if two Strings are anagram in Java. This method
 * assumes both arguments are not null and in lowercase.
 *
 * @return true, if both String are anagram
 */
public static boolean isAnagram(String word, String anagram){       
    if(word.length() != anagram.length()){
        return false;
    }

    char[] chars = word.toCharArray();

    for(char c : chars){
        int index = anagram.indexOf(c);
        if(index != -1){
            anagram = anagram.substring(0,index) + anagram.substring(index +1, anagram.length());
        }else{
            return false;
        }           
    }

    return anagram.isEmpty();
}

/*
 * Another way to check if two Strings are anagram or not in Java
 * This method assumes that both word and anagram are not null and lowercase
 * @return true, if both Strings are anagram.
 */
public static boolean iAnagram(String word, String anagram){
    char[] charFromWord = word.toCharArray();
    char[] charFromAnagram = anagram.toCharArray();       
    Arrays.sort(charFromWord);
    Arrays.sort(charFromAnagram);

    return Arrays.equals(charFromWord, charFromAnagram);
}


public static boolean checkAnagram(String first, String second){
    char[] characters = first.toCharArray();
    StringBuilder sbSecond = new StringBuilder(second);

    for(char ch : characters){
        int index = sbSecond.indexOf("" + ch);
        if(index != -1){
            sbSecond.deleteCharAt(index);
        }else{
            return false;
        }
    }

    return sbSecond.length()==0 ? true : false;
}

}

Answer 7

尝试一下。它将在O（word.length）中执行。

public boolean checkForAnagram(String str1, String str2) {
    if (str1 == null || str2 == null || str1.length() != str2.length()) {
        return false;
    }
    return Arrays.equals(getCharFrequencyTable(str1), getCharFrequencyTable(str2));
}

private int[] getCharFrequencyTable(String str) {
    int[] frequencyTable = new int[256]; //I am using array instead of hashmap to make you realize that its a constant time operation.
    char[] charArrayOfStr = str.toLowerCase().toCharArray();
    for(char c : charArrayOfStr) {
        frequencyTable[c] = frequencyTable[c]+1;
    }
    return frequencyTable;
}

Answer 8

您要在给定的字符串中添加字符的ascii值并进行比较，但这并不总是能为您提供正确的结果。考虑一下：

String a="acd"和String b="ccb"

他们两个都会给你296，但这些不是字谜。

您可以计算两个字符串中字符的出现次数并进行比较。在上面的示例中，它将为您提供{“ a”：1，“ c”：1，“ d”：1}和{“ c”：2，“ b”：1}。

此外，您可以将素数与每个字符集[a-z]关联，其中'a'匹配2，'b'匹配3，'c'匹配5，依此类推。

接下来，您可以计算与给定字符串中的字符关联的素数的乘法。乘法遵循关联规则（x y = y x）。

示例：

abc-> 2 * 3 * 5 = 30

cba-> 5 * 3 * 2 = 30

注意：如果字符串太大，则可能不是最佳方法，因为您可能会遇到溢出问题。

Anagrams-如何通过以下两个测试用例

8 个答案: