java - कैसे जांचें कि दो शब्द आरेख हैं या नहीं




string algorithm (20)

मेरे पास एक प्रोग्राम है जो आपको दिखाता है कि दो शब्द एक दूसरे के आरेख हैं या नहीं। ऐसे कुछ उदाहरण हैं जो ठीक से काम नहीं करेंगे और मैं किसी भी मदद की सराहना करता हूं, हालांकि यदि यह उन्नत नहीं था तो यह बहुत अच्छा होगा, क्योंकि मैं 1 साल का प्रोग्रामर हूं। "स्कूलीमास्टर" और "क्लासरूम" एक-दूसरे के आरेख हैं, हालांकि जब मैं "क्लासरूम" को "द क्लाउक्सरूम" में बदलता हूं, तब भी यह कहता है कि वे एनाग्राम हैं, मैं क्या गलत कर रहा हूं?

import java.util.ArrayList;
public class AnagramCheck
{
  public static void main(String args[])
  {
      String phrase1 = "tbeclassroom";
      phrase1 = (phrase1.toLowerCase()).trim();
      char[] phrase1Arr = phrase1.toCharArray();

      String phrase2 = "schoolmaster";
      phrase2 = (phrase2.toLowerCase()).trim();
      ArrayList<Character> phrase2ArrList = convertStringToArraylist(phrase2);

      if (phrase1.length() != phrase2.length()) 
      {
          System.out.print("There is no anagram present.");
      } 
      else 
      {
          boolean isFound = true;
          for (int i=0; i<phrase1Arr.length; i++)
          {  
              for(int j = 0; j < phrase2ArrList.size(); j++) 
              {
                  if(phrase1Arr[i] == phrase2ArrList.get(j))
                  {
                      System.out.print("There is a common element.\n");
                      isFound = ;
                      phrase2ArrList.remove(j);
                  }
              }
              if(isFound == false)
              {
                  System.out.print("There are no anagrams present.");
                  return;
              } 
          }
          System.out.printf("%s is an anagram of %s", phrase1, phrase2);
      }
  }

  public static ArrayList<Character> convertStringToArraylist(String str) {
      ArrayList<Character> charList = new ArrayList<Character>(); 
      for(int i = 0; i<str.length();i++){
          charList.add(str.charAt(i));
      }
      return charList;
  }
}

अधिक मेमोरी (अधिकांश एन / 2 तत्वों का हैश मैप) का उपयोग करके हमें स्ट्रिंग को सॉर्ट करने की आवश्यकता नहीं है।

public static boolean areAnagrams(String one, String two) {
    if (one.length() == two.length()) {
        String s0 = one.toLowerCase();
        String s1 = two.toLowerCase();
        HashMap<Character, Integer> chars = new HashMap<Character, Integer>(one.length());
        Integer count;
        for (char c : s0.toCharArray()) {
            count = chars.get(c);
            count = Integer.valueOf(count != null ? count + 1 : 1);
            chars.put(c, count);
        }
        for (char c : s1.toCharArray()) {
            count = chars.get(c);
            if (count == null) {
                return false;
            } else {
                count--;
                chars.put(c, count);
            }
        }
        for (Integer i : chars.values()) {
            if (i != 0) {
                return false;
            }
        }
        return true;
    } else {
        return false;
    }
}

यह फ़ंक्शन वास्तव में ओ (एन) में चल रहा है ... स्ट्रिंग्स के समाधान के लिए O (NlogN) के बजाय। अगर मुझे लगता है कि आप केवल वर्णमाला वर्णों का उपयोग करने जा रहे हैं, तो मैं हैशप के बजाय केवल 26 इंच (एक ज़ेड से उच्चारण या सजावट के बिना) का उपयोग कर सकता हूं।

अगर हम इसे परिभाषित करते हैं: एन = | एक | + | दो | हम एन पर एक पुनरावृत्ति करते हैं (एक बार काउंटरों को बढ़ाने के लिए, और एक बार उन्हें दो से कम करने के लिए)। फिर कुल योग की जांच करने के लिए हम मोस एन / 2 पर फिर से शुरू होते हैं।

वर्णित अन्य एल्गोरिदम का एक फायदा होता है: वे अतिरिक्त स्मृति का उपयोग नहीं करते हैं, यह मानते हुए कि Arrays.sort QuickSort के इनस्थल संस्करणों का उपयोग करता है या सॉर्ट विलय करता है। लेकिन चूंकि हम एनाग्राम के बारे में बात कर रहे हैं, मैं मानता हूं कि हम मानव भाषाओं के बारे में बात कर रहे हैं, इस प्रकार शब्दों को स्मृति के मुद्दों को देने के लिए पर्याप्त नहीं होना चाहिए।


आईएमएचओ, सबसे कुशल समाधान @ सिगुजा द्वारा प्रदान किया गया था, मैंने इसे अंतरिक्ष के साथ तारों को कवर करने के लिए विस्तारित किया है जैसे: "विलियम शेक्सपियर", "मैं एक कमजोर स्पेलर हूं", "स्कूल मास्टर", "कक्षा"

public int getAnagramScore(String word, String anagram) {

        if (word == null || anagram == null) {
            throw new NullPointerException("Both, word and anagram, must be non-null");
        }

        char[] wordArray = word.trim().toLowerCase().toCharArray();
        char[] anagramArray = anagram.trim().toLowerCase().toCharArray();

        int[] alphabetCountArray = new int[26];

        int reference = 'a';

        for (int i = 0; i < wordArray.length; i++) {
            if (!Character.isWhitespace(wordArray[i])) {
                alphabetCountArray[wordArray[i] - reference]++;
            }
        }
        for (int i = 0; i < anagramArray.length; i++) {
            if (!Character.isWhitespace(anagramArray[i])) {
                alphabetCountArray[anagramArray[i] - reference]--;
            }
        }

        for (int i = 0; i < 26; i++)
            if (alphabetCountArray[i] != 0)
                return 0;

        return word.length();

    }

ओ (एन) बिना किसी प्रकार के सॉर्टिंग के समाधान और केवल एक मानचित्र का उपयोग करना।

public boolean isAnagram(String leftString, String rightString) {
  if (leftString == null || rightString == null) {
    return false;
  } else if (leftString.length() != rightString.length()) {
    return false;
  }

  Map<Character, Integer> occurrencesMap = new HashMap<>();

  for(int i = 0; i < leftString.length(); i++){
    char charFromLeft = leftString.charAt(i);
    int nrOfCharsInLeft = occurrencesMap.containsKey(charFromLeft) ? occurrencesMap.get(charFromLeft) : 0;
    occurrencesMap.put(charFromLeft, ++nrOfCharsInLeft);
    char charFromRight = rightString.charAt(i);
    int nrOfCharsInRight = occurrencesMap.containsKey(charFromRight) ? occurrencesMap.get(charFromRight) : 0;
    occurrencesMap.put(charFromRight, --nrOfCharsInRight);
  }

  for(int occurrencesNr : occurrencesMap.values()){
    if(occurrencesNr != 0){
      return false;
    }
  }

  return true;
}

और कम सामान्य समाधान लेकिन थोड़ा तेज़ एक। आपको अपना वर्णमाला यहां रखना होगा:

public boolean isAnagram(String leftString, String rightString) {
  if (leftString == null || rightString == null) {
    return false;
  } else if (leftString.length() != rightString.length()) {
    return false;
  }

  char letters[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
  Map<Character, Integer> occurrencesMap = new HashMap<>();
  for (char l : letters) {
    occurrencesMap.put(l, 0);
  }

  for(int i = 0; i < leftString.length(); i++){
    char charFromLeft = leftString.charAt(i);
    Integer nrOfCharsInLeft = occurrencesMap.get(charFromLeft);
    occurrencesMap.put(charFromLeft, ++nrOfCharsInLeft);
    char charFromRight = rightString.charAt(i);
    Integer nrOfCharsInRight = occurrencesMap.get(charFromRight);
    occurrencesMap.put(charFromRight, --nrOfCharsInRight);
  }

  for(Integer occurrencesNr : occurrencesMap.values()){
    if(occurrencesNr != 0){
      return false;
    }
  }

  return true;
}

क्षमा करें, समाधान सी # में है, लेकिन मुझे लगता है कि समाधान पर आने वाले विभिन्न तत्व काफी सहज हैं। हाइफनेटेड शब्दों के लिए थोड़ा सा ट्विक आवश्यक है लेकिन सामान्य शब्दों के लिए इसे ठीक काम करना चाहिए।

    internal bool isAnagram(string input1,string input2)
    {
        Dictionary<char, int> outChars = AddToDict(input2.ToLower().Replace(" ", ""));
        input1 = input1.ToLower().Replace(" ","");
        foreach(char c in input1)
        {
            if (outChars.ContainsKey(c))
            {
                if (outChars[c] > 1)
                    outChars[c] -= 1;
                else
                    outChars.Remove(c);
            }
        }
        return outChars.Count == 0;
    }

    private Dictionary<char, int> AddToDict(string input)
    {
        Dictionary<char, int> inputChars = new Dictionary<char, int>();
        foreach(char c in input)
        {
            if(inputChars.ContainsKey(c))
            {
                inputChars[c] += 1;
            }
            else
            {
                inputChars.Add(c, 1);
            }     
        }
        return inputChars;
    }

टिप्पणी करने के दौरान टिप्पणी करने के लिए धन्यवाद, टिप्पणी करते समय मैंने पाया कि गलत तर्क था। मैंने कोड के प्रत्येक टुकड़े के लिए तर्क और अतिरिक्त टिप्पणी को सही किया।

// Time complexity: O(N) where N is number of character in String
// Required space :constant space.
// will work for string that contains ASCII chars

private static boolean isAnagram(String s1, String s2) {

    // if length of both string's are not equal then they are not anagram of each other 
    if(s1.length() != s2.length())return false;

    // array to store the presence of a character with number of occurrences.   
    int []seen = new int[256];

    // initialize the array with zero. Do not need to initialize specifically  since by default element will initialized by 0.
    // Added this is just increase the readability of the code. 
    Arrays.fill(seen, 0);

    // convert each string to lower case if you want to make ABC and aBC as anagram, other wise no need to change the case.  
    s1 = s1.toLowerCase();
    s2 = s2.toLowerCase();

    //  iterate through the first string and count the occurrences of each character
    for(int i =0; i < s1.length(); i++){
        seen[s1.charAt(i)] = seen[s1.charAt(i)] +1;
    }

    // iterate through second string and if any char has 0 occurrence then return false, it mean some char in s2 is there that is not present in s1.
    // other wise reduce the occurrences by one every time .
    for(int i =0; i < s2.length(); i++){
        if(seen[s2.charAt(i)] ==0)return false;
        seen[s2.charAt(i)] = seen[s2.charAt(i)]-1;
    }

    // now if both string have same occurrence of each character then the seen array must contains all element as zero. if any one has non zero element return false mean there are 
    // some character that either does not appear in one of the string or/and mismatch in occurrences 
    for(int i = 0; i < 256; i++){
        if(seen[i] != 0)return false;
    }
    return true;
}

दो शब्द एक दूसरे के आरेख हैं यदि उनमें समान संख्या में वर्ण और समान वर्ण होते हैं। आपको केवल अक्षरों को लेक्सिकोग्राफिक क्रम में क्रमबद्ध करने की आवश्यकता है, और तुलना करें कि स्ट्रिंग ए सभी चरणों में स्ट्रिंग बी के बराबर है या नहीं।

यहां एक कोड उदाहरण है। यह समझने के लिए एपीआई में Arrays में देखें कि क्या हो रहा है।

public boolean isAnagram(String firstWord, String secondWord) {
     char[] word1 = firstWord.replaceAll("[\\s]", "").toCharArray();
     char[] word2 = secondWord.replaceAll("[\\s]", "").toCharArray();
     Arrays.sort(word1);
     Arrays.sort(word2);
     return Arrays.equals(word1, word2);
}

मैं एक सी ++ डेवलपर हूं और नीचे दिया गया कोड सी ++ में है। मेरा मानना ​​है कि इसके बारे में जाने का सबसे तेज़ और आसान तरीका निम्न होगा:

आकार 26 की स्याही का एक वेक्टर बनाएं, सभी स्लॉट 0 से शुरू हो जाएं, और स्ट्रिंग के प्रत्येक अक्षर को वेक्टर में उचित स्थिति में रखें। याद रखें, वेक्टर वर्णानुक्रम में है और इसलिए यदि स्ट्रिंग में पहला अक्षर ज़ेड है, तो यह myvector [26] में जाएगा। नोट: यह ASCII वर्णों का उपयोग करके किया जा सकता है, इसलिए अनिवार्य रूप से आपका कोड इस तरह कुछ दिखाई देगा:

string s = zadg;
for(int i =0; i < s.size(); ++i){
    myvector[s[i] - 'a'] = myvector['s[i] - 'a'] + 1;
} 

तो सभी तत्वों को डालने से ओ (एन) समय लगेगा क्योंकि आप केवल एक बार सूची को पार करेंगे। अब आप दूसरी स्ट्रिंग के लिए एक ही चीज़ कर सकते हैं और वह भी ओ (एन) समय लेगा। फिर आप दो वैक्टरों की तुलना करके जांच कर सकते हैं कि प्रत्येक स्लॉट में काउंटर समान हैं या नहीं। यदि वे हैं, तो इसका मतलब है कि आपके पास दोनों तारों में प्रत्येक चरित्र का एक ही संख्या था और इस प्रकार वे एनाग्राम हैं। दो वैक्टरों की तुलना में ओ (एन) समय भी लेना चाहिए क्योंकि आप केवल एक बार इसके माध्यम से चल रहे हैं।

नोट: कोड केवल वर्णों के एक शब्द के लिए काम करता है। यदि आपके पास रिक्त स्थान, और संख्याएं और प्रतीकों हैं, तो आप केवल आकार 96 (ASCII वर्ण 32-127) का वेक्टर बना सकते हैं और कहने के बजाय - 'ए' आप कहेंगे - '' जैसा कि स्पेस कैरेक्टर में पहला है अक्षर की ASCII सूची।

मुझे आशा है कि वह मदद करेंगे। अगर मैंने कहीं गलती की है, तो कृपया एक टिप्पणी छोड़ दें।


यदि आप सरणी को सॉर्ट करते हैं, तो समाधान ओ (एन लॉग एन) बन जाता है। लेकिन अगर आप हैशपैप का उपयोग करते हैं, तो यह ओ (एन) है। परीक्षण और काम कर रहा है।

char[] word1 = "test".toCharArray();
char[] word2 = "tes".toCharArray();

Map<Character, Integer> lettersInWord1 = new HashMap<Character, Integer>();

for (char c : word1) {
    int count = 1;
    if (lettersInWord1.containsKey(c)) {
        count = lettersInWord1.get(c) + 1;
    }
    lettersInWord1.put(c, count);
}

for (char c : word2) {
    int count = -1;
    if (lettersInWord1.containsKey(c)) {
        count = lettersInWord1.get(c) - 1;
    }
    lettersInWord1.put(c, count);
}

for (char c : lettersInWord1.keySet()) {
    if (lettersInWord1.get(c) != 0) {
        return false;
    }
}

return true;

यहां कई जटिल उत्तर हैं। स्वीकार किए गए उत्तर पर आधार और 'ए' - 'बीबी' अंक का उल्लेख करते हुए टिप्पणी ए = 1 बी = 2 सी = 3 मानते हुए, हम केवल प्रत्येक पूर्णांक के वर्ग का उपयोग कर सकते हैं जो एक char का प्रतिनिधित्व करता है और समस्या को हल करता है:

public boolean anagram(String s, String t) {
    if(s.length() != t.length())
        return false;

    int value = 0;
    for(int i = 0; i < s.length(); i++){
        value += ((int)s.charAt(i))^2;
        value -= ((int)t.charAt(i))^2;
    }
    return value == 0;
}

यहां मेरा समाधान है। सबसे पहले तारों को चार सरणी में विस्फोट करें, फिर उन्हें क्रमबद्ध करें और फिर तुलना करें कि वे बराबर हैं या नहीं। मुझे लगता है कि इस कोड की समय जटिलता ओ (ए + बी) है। ए = बी हम कह सकते हैं ओ (2 ए)

public boolean isAnagram(String s1, String s2) {

        StringBuilder sb1 = new StringBuilder();
        StringBuilder sb2 = new StringBuilder();
        if (s1.length() != s2.length())
            return false;

        char arr1[] = s1.toCharArray();
        char arr2[] = s2.toCharArray();
        Arrays.sort(arr1);
        Arrays.sort(arr2);



        for (char c : arr1) {
            sb1.append(c);
        }

        for (char c : arr2) {
            sb2.append(c);
        }

        System.out.println(sb1.toString());
        System.out.println(sb2.toString());

        if (sb1.toString().equals(sb2.toString()))
            return true;
        else
            return false;

    }

सॉर्ट किए बिना कुछ अन्य समाधान।

public static boolean isAnagram(String s1, String s2){
    //case insensitive anagram

    StringBuffer sb = new StringBuffer(s2.toLowerCase());
    for (char c: s1.toLowerCase().toCharArray()){
        if (Character.isLetter(c)){

            int index = sb.indexOf(String.valueOf(c));
            if (index == -1){
                //char does not exist in other s2
                return false;
            }
            sb.deleteCharAt(index);
        }
    }
    for (char c: sb.toString().toCharArray()){
        //only allow whitespace as left overs
        if (!Character.isWhitespace(c)){
            return false;
        }
    }
    return true;
}

सॉर्टिंग या एकाधिक लूप या हैश मैप्स का उपयोग किए बिना यहां एक सरल तेज़ ओ (एन) समाधान है। हम पहली सरणी में प्रत्येक चरित्र की गिनती बढ़ाते हैं और दूसरी सरणी में प्रत्येक वर्ण की गणना घटाते हैं। यदि परिणामस्वरूप गणना सरणी शून्य से भरा है, तो तार आरेख हैं। गणना सरणी के आकार को बढ़ाकर अन्य वर्णों को शामिल करने के लिए विस्तारित किया जा सकता है।

class AnagramsFaster{

    private static boolean compare(String a, String b){
        char[] aArr = a.toLowerCase().toCharArray(), bArr = b.toLowerCase().toCharArray();
        if (aArr.length != bArr.length)
            return false;
        int[] counts = new int[26]; // An array to hold the number of occurrences of each character
        for (int i = 0; i < aArr.length; i++){
            counts[aArr[i]-97]++;  // Increment the count of the character at i
            counts[bArr[i]-97]--;  // Decrement the count of the character at i
        }
        // If the strings are anagrams, the counts array will be full of zeros
        for (int i = 0; i<26; i++)
            if (counts[i] != 0)
                return false;
        return true;
    }

    public static void main(String[] args){
        System.out.println(compare(args[0], args[1]));
    }
}

कोई भी कोड लिखने से पहले गणितज्ञ समस्या के बारे में सोच सकता है:

  1. स्ट्रिंग्स के बीच संबंध "एनाग्राम" एक समकक्ष संबंध है , इसलिए समीकरण वर्गों में सभी तारों का सेट विभाजन करता है।
  2. मान लीजिए कि हमारे पास प्रत्येक वर्ग से एक प्रतिनिधि (पालना) चुनने का नियम था, तो यह जांचना आसान है कि उनके प्रतिनिधि की तुलना करके दो वर्ग समान हैं या नहीं।
  3. तारों के एक सेट के लिए एक स्पष्ट प्रतिनिधि " लेक्सिकोग्राफिक ऑर्डर द्वारा सबसे छोटा तत्व " है, जो सॉर्ट करके किसी भी तत्व से गणना करना आसान है। उदाहरण के लिए, 'टोपी' युक्त एनाग्राम वर्ग का प्रतिनिधि 'आह' है।

आपके उदाहरण में "स्कूलीमास्टर" और "क्लासरूम" एनाग्राम हैं क्योंकि वे दोनों एनाग्राम कक्षा में पालना "acehlmoorsst" के साथ हैं।

छद्म कोड में:

>>> def crib(word):
...     return sorted(word)
...
>>> crib("schoolmaster") == crib("theclassroom")
True

A way to solve this - based on Sai Kiran's answer..

import java.util.Scanner;

public class Anagram {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Enter first word : ");
        String word1 = sc.nextLine();
        System.out.print("Enter second word : ");
        String word2 = sc.nextLine();

        sc.close();

        System.out.println("Is Anagram : " + isAnagram(word1, word2));
    }

    private static boolean isAnagram(String word1, String word2) {

        if (word1.length() != word2.length()) {
            System.err.println("Words length didn't match!");
            return false;
        }

        char ch1, ch2;
        int len = word1.length(), sumOfWord1Chars = 0, sumOfWord2Chars = 0;

        for (int i = 0; i < len; i++) {
            ch1 = word1.charAt(i);
            if (word2.indexOf(ch1) < 0) {
                System.err.println("'" + ch1 + "' not found in \"" + word2
                        + "\"");
                return false;
            }
            sumOfWord1Chars += word1.charAt(i);

            ch2 = word2.charAt(i);
            if (word1.indexOf(ch2) < 0) {
                System.err.println("'" + ch2 + "' not found in \"" + word1
                        + "\"");
                return false;
            }
            sumOfWord2Chars += word2.charAt(i);
        }

        if (sumOfWord1Chars != sumOfWord2Chars) {
            System.err
                    .println("Sum of both words didn't match, i.e., words having same characters but with different counts!");
            return false;
        }

        return true;
    }
}

I had written this program in java. I think this might also help:

public class Anagram {
    public static void main(String[] args) {
        checkAnagram("listen", "silent");
    }

    public static void checkAnagram(String str1, String str2) {
        boolean isAnagram = false;
        str1 = sortStr(str1);
        str2 = sortStr(str2);
        if (str1.equals(str2)) {
            isAnagram = true;
        }
        if (isAnagram) {
            System.out.println("Two strings are anagram");
        } else {
            System.out.println("Two string are not anagram");
        }

    }

    public static String sortStr(String str) {
        char[] strArr = str.toCharArray();
        for (int i = 0; i < str.length(); i++) {
            for (int j = i + 1; j < str.length(); j++) {
                if (strArr[i] > strArr[j]) {
                    char temp = strArr[i];
                    strArr[i] = strArr[j];
                    strArr[j] = temp;
                }
            }
        }
        String output = String.valueOf(strArr);
        return output;
    }
}

I know this is an old question. However, I'm hoping this can be of help to someone. The time complexity of this solution is O(n^2).

public boolean areAnagrams(final String word1, final String word2) {
        if (word1.length() != word2.length())
            return false;

        if (word1.equals(word2))
            return true;

        if (word1.length() == 0 && word2.length() == 0)
            return true;

        String secondWord = word2;
        for (int i = 0; i < word1.length(); i++) {
            if (secondWord.indexOf(word1.charAt(i)) == -1)
                return false;

            secondWord = secondWord.replaceFirst(word1.charAt(i) + "", "");
        }

        if (secondWord.length() > 0)
            return false;

        return true;
}

So far all proposed solutions work with separate char items, not code points. I'd like to propose two solutions to properly handle surrogate pairs as well (those are characters from U+10000 to U+10FFFF , composed of two char items).

1) One-line O(n logn) solution which utilizes Java 8 CharSequence.codePoints() stream:

static boolean areAnagrams(CharSequence a, CharSequence b) {
    return Arrays.equals(a.codePoints().sorted().toArray(),
                         b.codePoints().sorted().toArray());
}

2) Less elegant O(n) solution (in fact, it will be faster only for long strings with low chances to be anagrams) :

static boolean areAnagrams(CharSequence a, CharSequence b) {
    int len = a.length();
    if (len != b.length())
        return false;

    // collect codepoint occurrences in "a"
    Map<Integer, Integer> ocr = new HashMap<>(64);
    a.codePoints().forEach(c -> ocr.merge(c, 1, Integer::sum));

    // for each codepoint in "b", look for matching occurrence
    for (int i = 0, c = 0; i < len; i += Character.charCount(c)) {
        int cc = ocr.getOrDefault((c = Character.codePointAt(b, i)), 0);
        if (cc == 0)                        
            return false;            
        ocr.put(c, cc - 1);
    }
    return true;
}

Works perfectly! But not a good approach because it runs in O(n^2)

boolean isAnagram(String A, String B) {
    if(A.length() != B.length())
        return false;

   A = A.toLowerCase();
   B = B.toLowerCase();

   for(int i = 0; i < A.length(); i++){
       boolean found = false;
       for(int j = 0; j < B.length(); j++){
           if(A.charAt(i) == B.charAt(j)){
               found = true;
               break;
           }
       }
       if(!found){
           return false;
       }
   }

   for(int i = 0; i < B.length(); i++){
       boolean found = false;
       for(int j = 0; j < A.length(); j++){
           if(A.charAt(j) == B.charAt(i)){
               found = true;
               break;
           }
       }
       if(!found){
           return false;
       }
   }

   int sum1 = 0, sum2 = 0;
   for(int i = 0; i < A.length(); i++){
       sum1 += (int)A.charAt(i);
       sum2 += (int)B.charAt(i);               
   }

   if(sum1 == sum2){
       return true;
   } 
   return false;
}

    /*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package Algorithms;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import javax.swing.JOptionPane;

/**
 *
 * @author Mokhtar
 */
public class Anagrams {

    //Write aprogram to check if two words are anagrams
    public static void main(String[] args) {
        Anagrams an=new Anagrams();
        ArrayList<String> l=new ArrayList<String>();
        String result=JOptionPane.showInputDialog("How many words to test anagrams");
        if(Integer.parseInt(result) >1)
        {    
            for(int i=0;i<Integer.parseInt(result);i++)
            {

                String word=JOptionPane.showInputDialog("Enter word #"+i);
                l.add(word);   
            }
            System.out.println(an.isanagrams(l));
        }
        else
        {
            JOptionPane.showMessageDialog(null, "Can not be tested, \nYou can test two words or more");
        }

    }

    private static String sortString( String w )
    {
        char[] ch = w.toCharArray();
        Arrays.sort(ch);
        return new String(ch);
    }

    public boolean isanagrams(ArrayList<String> l)
    {
        boolean isanagrams=true; 
        ArrayList<String> anagrams = null;
        HashMap<String, ArrayList<String>> map =  new HashMap<String, ArrayList<String>>();
        for(int i=0;i<l.size();i++)
            {
        String word = l.get(i);
        String sortedWord = sortString(word);
            anagrams = map.get( sortedWord );
        if( anagrams == null ) anagrams = new ArrayList<String>();
        anagrams.add(word);
        map.put(sortedWord, anagrams);
            }

            for(int h=0;h<l.size();h++)
            {
                if(!anagrams.contains(l.get(h)))
                {
                    isanagrams=false;
                    break;
                }
            }

            return isanagrams;
        //}
        }

}

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
/**
 * Check if Anagram by Prime Number Logic
 * @author Pallav
 *
 */
public class Anagram {
    public static void main(String args[]) {
        System.out.println(isAnagram(args[0].toUpperCase(),
                args[1].toUpperCase()));
    }
/**
 * 
 * @param word : The String 1
 * @param anagram_word : The String 2 with which Anagram to be verified
 * @return true or false based on Anagram
 */
    public static Boolean isAnagram(String word, String anagram_word) {
        //If length is different return false
        if (word.length() != anagram_word.length()) {
            return false;
        }
        char[] words_char = word.toCharArray();//Get the Char Array of First String
        char[] anagram_word_char = anagram_word.toCharArray();//Get the Char Array of Second String
        int words_char_num = 1;//Initialize Multiplication Factor to 1
        int anagram_word_num = 1;//Initialize Multiplication Factor to 1 for String 2
        Map<Character, Integer> wordPrimeMap = wordPrimeMap();//Get the Prime numbers Mapped to each alphabets in English
        for (int i = 0; i < words_char.length; i++) {
            words_char_num *= wordPrimeMap.get(words_char[i]);//get Multiplication value for String 1
        }
        for (int i = 0; i < anagram_word_char.length; i++) {
            anagram_word_num *= wordPrimeMap.get(anagram_word_char[i]);//get Multiplication value for String 2
        }

        return anagram_word_num == words_char_num;
    }
/**
 * Get the Prime numbers Mapped to each alphabets in English
 * @return
 */
    public static Map<Character, Integer> wordPrimeMap() {
        List<Integer> primes = primes(26);
        int k = 65;
        Map<Character, Integer> map = new TreeMap<Character, Integer>();
        for (int i = 0; i < primes.size(); i++) {
            Character character = (char) k;
            map.put(character, primes.get(i));
            k++;
        }
        // System.out.println(map);
        return map;
    }
/**
 * get first N prime Numbers where Number is greater than 2
 * @param N : Number of Prime Numbers
 * @return
 */
    public static List<Integer> primes(Integer N) {
        List<Integer> primes = new ArrayList<Integer>();
        primes.add(2);
        primes.add(3);

        int n = 5;
        int k = 0;
        do {
            boolean is_prime = true;
            for (int i = 2; i <= Math.sqrt(n); i++) {
                if (n % i == 0) {
                    is_prime = false;
                    break;
                }
            }

            if (is_prime == true) {
                primes.add(n);

            }
            n++;
            // System.out.println(k);
        } while (primes.size() < N);

        // }

        return primes;
    }

}






anagram