是两个字谜吗？ [关闭]

Question

我的问题是，在这段代码中，最初我们将布尔 isAnagram 设为 false，然后设置条件，但我们得到了错误的结果。很明显，它们不是字谜，但代码输出是'字谜'。

package strings;

public class Anagrams {

    public static void main(String[] args) {
        
        String a = "aab";
        String b = "abc";
        
        boolean isAnagram = false;
        
        int al[] = new int[256];
        int bl[] = new int[256];
        
        for(char c:a.toCharArray()) {
            int index = (int)c;
            al[index]++;
            }
        for(char c:b.toCharArray()) {
            int index = (int)c;
            bl[index]++;
            }
        
        for(int i = 0; i<256; i++) {
            if(al[i] == bl[i]) {
                isAnagram = true;
            }
        }
        
        if(isAnagram) {
            System.out.println("anagram");
        }else {
            System.out.println("not anagram");
        }
    
        }
    }
}

Answer 1

我认为对字符串进行排序然后比较它们更简单。

public static void main(String[] args) {

    String a = "aab";
    String b = "abc";

    char[] a1 = a.toLowerCase().toCharArray();
    char[] b1 = b.toLowerCase().toCharArray();

    Arrays.sort(a1);
    Arrays.sort(b1);
    
    boolean isAnagram = new String(a1).equals(new String(b1));

    System.out.println(isAnagram ? "anagram" : "not anagram");
}

Answer 2

好的。

提问者希望他自己的算法能够工作。 主要的错误是它需要在字符集中找到不匹配的两个单词。

因此，您可以声明一个计数器，并在遍历两个单词中的 char 位置时，每次发现第一个和第二个单词中某些特定字母的数量不匹配时，都会增加计数器。

最后，如果计数器 > 0，这意味着单词有不同的字符集。

工作代码：

class Ideone
{
// Online Java Compiler
// Use this editor to write, compile and run your Java code online


public static void main(String[] args) {
        
        String a = "aab";
        String b = "abb";
        int mismatch = 0;
        
        boolean isAnagram = true;
        
        int al[] = new int[143859];
        int bl[] = new int[143859];
        
        for(char c:a.toCharArray()) {
            int index = (int)c;
            al[index]++;
            }
        for(char c:b.toCharArray()) {
            int index = (int)c;
            bl[index]++;
            }
        
        for(int i = 0; i<143859; i++) {
            if(al[i] != bl[i]) {
                mismatch++;
            }
        }
        
        if (mismatch>0) isAnagram = false;
        
        if(isAnagram) {
            System.out.println("anagram");
        }else {
            System.out.println("not anagram");
        }
    
        }

}

Answer 3

如果一个字符计数匹配，您的代码将生成 true。但如果所有字符计数都匹配，则它应该只是true。翻转逻辑，从true 开始，在第一个不匹配时设置为false。换行

boolean isAnagram = false;

到

boolean isAnagram = true;

和

if(al[i] == bl[i]) {
    isAnagram = true;
}

到

if(al[i] != bl[i]) {
    isAnagram = false;
    break;
}

但是对字符串进行排序确实是更具可读性和易于理解的解决方案。

Answer 4

问题是最后一个for-loop：

for(int i = 0; i<256; i++) {
    if(al[i] == bl[i]) {
        isAnagram = true;
    }
}

如果两个数组中只有一个位置匹配，则isAnagram 设置为true。为了解决这个问题，我们可以颠倒我们的观点：让我们假设两个Strings 是开头的字谜（boolean isAnagram = true;）并将标志设置为false iff。两个数组a 和b 在某些索引i 上不同。我们也可以在我们发现的第一个不匹配处打破循环。

public static void main(String[] args) {
  String a = "aab";
  String b = "aac";

  boolean isAnagram = true;

  int al[] = new int[256];
  int bl[] = new int[256];

  for (char c : a.toCharArray()) {
    int index = (int) c;
    al[index]++;
  }
  for (char c : b.toCharArray()) {
    int index = (int) c;
    bl[index]++;
  }

  for (int i = 0; i < 256; i++) {
    if (al[i] != bl[i]) {
      isAnagram = false;
      break;
    }
  }

  if (isAnagram) {
    System.out.println("anagram");
  } else {
    System.out.println("not anagram");
  }
}

Ideone demo

由于 Java 中的 chars 以​​ unicode 编码，因此 char 的 int 值可能是 >= 256 (Ideone demo)。为了防止这个问题，我们可以使用Map<Integer, Integer> 来跟踪代码点频率：

public static boolean areAnagrams(String s, String t) {
  Objects.requireNonNull(s, "Parameter \"s\" is null");
  Objects.requireNonNull(t, "Parameter \"t\" is null");
  return Objects.equals(s, t) ||
      Objects.equals(getCodePointFrequency(s), getCodePointFrequency(t));
}

public static Map<Integer, Integer> getCodePointFrequency(String s) {
  return s.codePoints()
      .boxed()
      .collect(Collectors.toMap(Function.identity(), c -> 1, Integer::sum));
}

Ideone demo

应该提到的是，这个解决方案的最坏情况时间复杂度为O(n log(n))，因为插入到映射中只能保证O(log(n))，而不是O(1)。然而，平均情况应该是O(max(n))，n 是s 和t 中较长的String 的长度。