字謎 - 如何通過以下兩個測試用例

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”
更好的方法是對字符串的字符進行排序，如果它們具有相同的數組長度和相同的順序，那么兩個字符串是anagram。

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

你應該檢查每個字母。 如果（[0] = ascii為b [0] + 1）的ascii和（[1]的ascii = = ascii of b [1] - 1）它將返回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}。

此外，您可以將素數與每個字符集[az]相關聯，其中'a'匹配2，'b'匹配3，'c'匹配5，依此類推。

接下來，您可以計算與給定字符串中的字符關聯的素數的乘積。 乘法遵循相關性規則（x y = y x）。

例：

abc - > 2 * 3 * 5 = 30

cba - > 5 * 3 * 2 = 30

注意：如果字符串大小很大，這可能不是最好的方法，因為您可能會遇到溢出問題。