字謎檢查的最佳解決方案？

Question

我正在解決一個排列/字謎問題，並希望輸入最有效的檢查方法。 現在，我在 Java 領域做這件事，因此有一個包括排序在內的所有東西的庫。 檢查兩個字符串是否互為變位詞的第一種方法是檢查長度，以某種方式對它們進行排序，然后比較所述字符串的每個索引。 代碼如下：

private boolean validAnagram(String str, String pair) {
if(str.length() != pair.length()){
    return false;
}

char[] strArr = str.toCharArray();
char[] pairArr = pair.toCharArray();


Arrays.sort(strArr);
str = new String(strArr);

Arrays.sort(pairArr);
pair = new String(pairArr);

for(int i = 0; i<str.length(); i++){
    if(str.charAt(i) != pair.charAt(i)){
        return false;
    }
}
return true;
}

或者，我認為根據 ascii 值進行檢查並避免檢查每個可能的字符會更容易。 代碼如下：

private boolean validAnagram(String str, String pair) {
if(str.length() != pair.length()){
    return false;
}

char[] strArr = str.toCharArray();
char[] pairArr = pair.toCharArray();



int strValue = 0;
int pairValue = 0;

for(int i =0; i < strArr.length; i++){
    strValue+= (int) strArr[i];
    pairValue+= (int) pairArr[i];
}

if(strValue != pairValue){
    return false;
}
return true;
}

那么，哪個是更好的解決方案？ 我不太了解 Arrays 給我的類型，但是當我環顧舊互聯網時，這是更常見的答案。 讓我懷疑我是否遺漏了什么。

Answer 1

這是一個非常簡單的實現。

public boolean isAnagram(String strA, String strB) {
  // Cleaning the strings (remove white spaces and convert to lowercase)
  strA = strA.replaceAll("\\s+","").toLowerCase();
  strB = strB.replaceAll("\\s+","").toLowerCase();

  // Check every char of strA and removes first occurence of it in strB
  for (int i = 0; i < strA.length(); i++ ) {
    if (strB.equals("")) return false;  // strB is already empty : not an anagram
    strB = strB.replaceFirst(Pattern.quote("" + strA.charAt(i)), "");
  }

  // if strB is empty we have an anagram
  return strB.equals("");
}

最后：

System.out.println(isAnagram("William Shakespeare", "I am a weakish speller")); // true

Answer 2

這是一個更簡單、易於閱讀的解決方案，我能夠編譯...

    static boolean isAnagram(String a, String b) {
    if (a.length() == b.length()){
        char[] arr1 = a.toLowerCase().toCharArray();
        char[] arr2 = b.toLowerCase().toCharArray();
        Arrays.sort(arr1);
        Arrays.sort(arr2);
        if (Arrays.equals(arr1, arr2)) return true;
        else return false;
    }else return false;
}

最好的，賈斯汀

Answer 3

有幾種方法可以檢查兩個字符串是否為字謎。 你的問題是，哪一個是更好的解決方案。 您的第一個解決方案具有排序邏輯。 排序的最壞情況復雜度為 (nlogn) 。 您的第二個邏輯僅使用一個復雜度為 O(n) 的循環。

所以在這兩個中，只有 O(n) 復雜度的第二個解決方案將是比第一個更好的解決方案。

一種可能的解決方案：

 private boolean checkAnagram(String stringOne , String stringTwo){ char[] first = stringOne.toLowerCase().toCharArray(); char[] second = stringTwo.toLowerCase().toCharArray(); // if length of strings is not same if (first.length != second.length) return false; int[] counts = new int[26]; for (int i = 0; i < first.length; i++){ counts[first[i]-97]++; counts[second[i]-97]--; } for (int i = 0; i<26; i++) if (counts[i] != 0) return false; return true; }

Answer 4

我的解決方案：時間復雜度 = O(n)

public static boolean isAnagram(String str1, String str2) {
    if (str1.length() != str2.length()) {
        return false;
    }

    for (int i = 0; i < str1.length(); i++) {
        char ch = str1.charAt(i);

        if (str2.indexOf(ch) == -1) 
            return false;
        else
            str2 = str2.replaceFirst(String.valueOf(ch), " ");
    }

    return true;
}

測試用例：

@Test
public void testIsPernutationTrue() {
    assertTrue(Anagram.isAnagram("abc", "cba"));
    assertTrue(Anagram.isAnagram("geeksforgeeks", "forgeeksgeeks"));
    assertTrue(Anagram.isAnagram("anagram", "margana"));
}

@Test
public void testIsPernutationFalse() {
    assertFalse(Anagram.isAnagram("abc", "caa"));
    assertFalse(Anagram.isAnagram("anagramm", "marganaa"));
}

Answer 5

最佳解決方案取決於您的目標、代碼大小、內存占用或最少的計算。

一個非常酷的解決方案，盡可能少的代碼，不是最快的 O(nlog n) 並且在 Java 8 中內存效率很低：

public class Anagram {
  public static void main(String[] argc) {
    String str1 = "gody";
    String str2 = "dogy";

    boolean isAnagram =
    str1.chars().mapToObj(c -> (char) c).sorted().collect(Collectors.toList())
    .equals(str2.chars().mapToObj(c -> (char) c).sorted().collect(Collectors.toList()));

    System.out.println(isAnagram);
  }
}

Answer 6

我使用 Sets 嘗試了一些解決方案，並使每個解決方案運行 1000 萬次以使用您的示例數組進行測試：

private static String[] input = {"tea", "ate", "eat", "apple", "java", "vaja", "cut", "utc"};

首先，我用來調用這些算法的方法：

public static void main(String[] args) {
    long startTime = System.currentTimeMillis();
    for (int x = 0; x < 10000000; x++) {
        Set<String> confirmedAnagrams = new HashSet<>();
        for (int i = 0; i < (input.length / 2) + 1; i++) {
            if (!confirmedAnagrams.contains(input[i])) {
                for (int j = i + 1; j < input.length; j++) {
                        if (isAnagrams1(input[i], input[j])) {
                            confirmedAnagrams.add(input[i]);
                            confirmedAnagrams.add(input[j]);
                        }
                }
            }
        }
        output = confirmedAnagrams.toArray(new String[confirmedAnagrams.size()]);
    }
    long endTime = System.currentTimeMillis();
    System.out.println("Total time: " + (endTime - startTime));
    System.out.println("Average time: " + ((endTime - startTime) / 10000000D));
}

然后我使用了基於字符 HashSet 的算法。 我將每個單詞的每個字符添加到 HashSet 中，如果 HashSet 不是首字母單詞的長度，則意味着它們不是字謎。

我的算法及其運行時：

算法 1：

    private static boolean isAnagrams1(String x, String y) {
    if (x.length() != y.length()) {
        return false;
    } else if (x.equals(y)) {
        return true;
    }

    Set<Character> anagramSet = new HashSet<>();
    for (int i = 0; i < x.length(); i++) {
        anagramSet.add(x.charAt(i));
        anagramSet.add(y.charAt(i));
    }

    return anagramSet.size() != x.length();
}

這具有以下運行時：

Total time: 6914
Average time: 6.914E-4

算法2

private static boolean isAnagrams2(String x, String y) {
    if (x.length() != y.length()) {
        return false;
    } else if (x.equals(y)) {
        return true;
    }

    Set<Character> anagramSet = new HashSet<>();
    char[] xAr = x.toCharArray();
    char[] yAr = y.toCharArray();
    for (int i = 0; i < xAr.length; i++) {
        anagramSet.add(xAr[i]);
        anagramSet.add(yAr[i]);
    }

    return anagramSet.size() != x.length();
}

運行時間為：

Total time: 8752
Average time: 8.752E-4

算法3

對於這個算法，我決定將 Set 發送通過，因此我每個周期只創建一次，並在每次測試后清除它。

    private static boolean isAnagrams3(Set<Character> anagramSet, String x, String y) {
    if (x.length() != y.length()) {
        return false;
    } else if (x.equals(y)) {
        return true;
    }

    for (int i = 0; i < x.length(); i++) {
        anagramSet.add(x.charAt(i));
        anagramSet.add(y.charAt(i));
    }

    return anagramSet.size() != x.length();
}

運行時間為：

Total time: 8251
Average time: 8.251E-4

算法 4

這個算法不是我的，它屬於Pratik Upacharya ，他也回答了這個問題，以便我比較：

    private static boolean isAnagrams4(String stringOne, String stringTwo) {
    char[] first = stringOne.toLowerCase().toCharArray();
    char[] second = stringTwo.toLowerCase().toCharArray();
    // if length of strings is not same 
    if (first.length != second.length) {
        return false;
    }
    int[] counts = new int[26];
    for (int i = 0; i < first.length; i++) {
        counts[first[i] - 97]++;
        counts[second[i] - 97]--;
    }
    for (int i = 0; i < 26; i++) {
        if (counts[i] != 0) {
            return false;
        }
    }
    return true;
}

運行時間為：

Total time: 5707
Average time: 5.707E-4

當然，每次測試運行時這些運行時確實不同，為了進行適當的測試，需要更大的示例集，並且可能需要更多的迭代。

*編輯，因為我在最初的方法中犯了一個錯誤， Pratik Upacharya's算法似乎是更快Pratik Upacharya's算法

Answer 7

//here best solution for an anagram
import java.util.*;

class Anagram{
public static void main(String arg[]){

Scanner sc =new Scanner(System.in);
String str1=sc.nextLine();
String str2=sc.nextLine();
int i,j;

boolean Flag=true;
i=str1.length();
j=str2.length();


if(i==j){
for(int m=0;m<i;m++){
    for(int n=0;n<i;n++){
        if(str1.charAt(m)==str2.charAt(n)){
           Flag=true;
           break;
          }
          else
          Flag=false;
    }
}
}
else{
Flag=false;
}

if(Flag)
System.out.println("String is Anagram");
else
System.out.println("String is not Anagram");
}
}

Answer 8

最近一個招聘人員讓我解決這個問題。 在研究這個問題時，我想出了一個解決方案來解決兩種類型的字謎問題。

問題 1：確定文本正文中是否存在字謎。

問題 2：確定正文中是否存在正式的字謎。 在這種情況下，字謎必須與您比較的文本大小相同。 在前一種情況下，兩個文本的大小不必相同。
一個只需要包含另一個。

我的方法如下：

設置階段：首先創建一個字謎類。 這只會將文本轉換為 Map ，其鍵是相關字符，值包含輸入字符的出現次數。 我認為這最多需要 O(n) 時間復雜度。 由於這最多需要兩個映射，最壞情況的復雜度將是 O(2n)。 至少我對漸近符號的天真理解是這樣說的。

處理階段：您需要做的就是遍歷兩個 Map 中較小的一個，然后在較大的 Map 中查找。 如果它不存在，或者如果它存在但出現次數不同，則它不能作為字謎測試。

這是確定我們是否有字謎的循環：

    boolean looking = true;
        for (Anagram ele : smaller.values()) {
            Anagram you = larger.get(ele);
                if (you == null || you.getCount() != ele.getCount()) {
                    looking = false;
                    break;
                }
        }
        return looking;

請注意，我創建了一個 ADT 來包含正在處理的字符串。 它們首先被轉換為 Map。

以下是創建 Anagram 對象的代碼片段：

    private void init(String teststring2) {
        StringBuilder sb = new StringBuilder(teststring2);
        for (int i = 0; i &lt sb.length(); i++) {
            Anagram a = new AnagramImpl(sb.charAt(i));
            Anagram tmp = map.putIfAbsent(a, a);
            if (tmp != null) {
                tmp.updateCount();
            }
        }
    }

Answer 9

我想出了一個解決方案，我什至沒有使用任何 26 個字符的數組……看看這個：

StringBuffer a = new StringBuffer();
        a.append(sc.next().toLowerCase());

        StringBuffer b = new StringBuffer();
        b.append(sc.next().toLowerCase());
        if(a.length() !=b.length())
        {
            System.out.println("NO");
            continue;
        }
        int o =0;
        for(int i =0;i<a.length();i++)
        {
            if(a.indexOf(String.valueOf(b.charAt(i)))<0)
            {
               System.out.println("NO");
               o=1;break; 

            }
        }
        if(o==0)
         System.out.println("Yes");

Answer 10

考慮使用HashMap和Arrays.sort

    private static Map<String, String> getAnagrams(String[] data) {

    Map<String, String> anagrams = new HashMap<>();
    Map<String, String> results = new HashMap<>();

    for (int i = 0; i < data.length; i++) {

        char[] chars = data[i].toLowerCase().toCharArray();
        Arrays.sort(chars);

        String sorted = String.copyValueOf(chars);

        String item = anagrams.get(sorted);
        if (item != null) {
            anagrams.put(sorted, item + ", " + i);
            results.put(sorted, anagrams.get(sorted));
        } else {
            anagrams.put(sorted, String.valueOf(i));
        }
    }

    return results;
}

我喜歡它，因為你只遍歷數組一次。

Answer 11

使用原始數據類型的解決方案。

boolean isAnagram(char input1[], char input2[]) {
    int bitFlip = 32;

    if(input2.length != input1.length){return false;}

    boolean found = false;
    for (int x = 0; x < input1.length; x++) {
        found = false;
        for (int y = 0; y < input2.length; y++) {
             if (!found && ((input1[x] | bitFlip)) ==
             ( (input2[y] | bitFlip))) {
                found = true;
                input2[y] = 0;
            }
        }
        if (!found) {
            break;
        }
    }
    return found ;
}

這種方法不依賴於任何排序實用程序。 它的作用是通過迭代找到值，並在找到后將其設置為零以避免輸入重復字符，例如“pool”和“loop”，其中包含兩個字母“o”。

它還通過翻轉位來忽略不依賴 toLowerCase() 的情況，因為如果第 6 位（十進制為 32）為 1，則為小寫字母，如果為零則為大寫字母。

它是直接字節操作，所以它會像圖像操作中使用的那樣表現得更好。 也許缺點是 O(n^2)。

這是在hackerrank中測試的解決方案