Java 字谜-我如何通过以下两个测试用例

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

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

静态布尔isAnagram（字符串a、字符串b）{
如果（a.length（）！=b.length（））返回false；
a=a.toLowerCase（）；
b=b.toLowerCase（）；
int m1=0；
对于（int i=0；i
静态布尔值isAnagram（字符串a、字符串b）{
如果（a.长度（）！=b.长度（））
返回false；
a=a.toLowerCase（）；
b=b.toLowerCase（）；
HashMap m1=new HashMap（）；//键是ascii数，值是count。对于字符串a
HashMap m2=new HashMap（）；//键是ascii数，值是count。对于字符串b
对于（int i=0；i

你应该检查每封信。
如果（a[0]==b[0]+1的ascii）和（a[1]==b[1]-1的ascii），它将返回true，因为1-1为零。
很抱歉，代码非常复杂。
实现不正确。虽然一对字谜总是具有相同的长度和相同的字符总数，但这不是一个充分条件。有许多对字符串具有相同的长度和相同的字符总数，并且不是字谜。例如，
“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()));
}

公共静态布尔isAnagram（字符串a、字符串b）{
返回charCounts（a）。等于（charCounts（b））；
}
私有静态映射字符数（字符串）{
返回s.chars（）
.boxed（）
.collect（Collectors.groupingBy（Function.identity（）、Collectors.counting（））；
}
我认为您的代码不起作用，因为您将字符代码相加，但答案可能为零，但它们并不相等，例如：“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);
}

我希望这对您有所帮助。（这有点困难，因为我使用stream创建和排序字符数组）
尝试以下方法：

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

import java.io.*；
类GFG{
/*函数来检查两个字符串是否相同
彼此的字谜*/
静态布尔区域内存（char[]str1，char[]str2）
{ 
//获取两个字符串的长度
int n1=str1.1长度；
int n2=str2.1长度；
//如果两个字符串的长度不相同，
//那么它们就不能是字谜了
如果（n1！=n2）
返回false；
//对两个字符串进行排序
快速排序（str1，0，n1-1）；
快速排序（str2，0，n2-1）；
//比较排序的字符串
对于（int i=0；i结束索引
*/
静态无效快速排序（字符A[]，整数si，整数ei）
{ 
int pi；/*分区索引*/
if（si
添加字符值是一种容易出错的逻辑，因为
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);
}

这会给你想要的。
检查以下方法：

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

}
试试这个。它将在O（字长）中执行

您在给定字符串中添加字符的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，依此类推

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

例如：

abc-->2*3*5=30

cba-->5*3*2=30

注意：如果字符串大小很大，这可能不是最好的方法，因为您可能会遇到溢出问题。
我相信您的代码是正确的。因为xyxy不是xyzw的拼音。拼音意味着使用单词中的相同字母
/**
 * 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;
}

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