3 Ways to Solve Anagram in Java

In simple terms, an anagram is a word or phrase that is formed by rearranging the letters of another word or phrase. To determine if two strings are anagrams, they must contain the same characters with the exact same frequency, although the order of characters may differ.

For example:

• “listen” and “silent” are anagrams.
• “triangle” and “integral” are anagrams.
• “night” and “thing” are anagrams.

Anagram in Java: Concept Overview

In Java, to check whether two strings are anagrams, you would need to compare the characters in both strings. This involves ensuring both strings:

• Have the same length.
• Contain the exact same characters with the same frequency.

Let’s dive into some solutions with different approaches.

Solution 1: Sorting Approach

One of the simplest ways to check for anagrams is by sorting both strings and then comparing them. If the sorted versions of both strings are equal, they are anagrams.

Steps:

1. Convert both strings to character arrays.
2. Sort both arrays.
3. Compare the sorted arrays.

Code Example:

import java.util.Arrays;

public class CheckAnagram1 {
    public static boolean areAnagrams(String str1, String str2) {
        // Remove spaces and convert strings to lowercase
        str1 = str1.replaceAll("\\s", "").toLowerCase();
        str2 = str2.replaceAll("\\s", "").toLowerCase();

        // Check if the lengths are the same
        if (str1.length() != str2.length()) {
            return false;
        }

        // Convert strings to character arrays and sort them
        char[] arr1 = str1.toCharArray();
        char[] arr2 = str2.toCharArray();
        Arrays.sort(arr1);
        Arrays.sort(arr2);

        // Compare sorted arrays
        return Arrays.equals(arr1, arr2);
    }

    public static void main(String[] args) {
        String str1 = "Listen";
        String str2 = "Silent";

        if (areAnagrams(str1, str2)) {
            System.out.println(str1 + " and " + str2 + " are anagrams.");
        } else {
            System.out.println(str1 + " and " + str2 + " are not anagrams.");
        }
    }
}

Explanation:

• First, we clean up the strings by removing spaces and converting them to lowercase.
• We then check if both strings have the same length. If not, they can’t be anagrams.
• We convert each string into a character array, sort the arrays, and compare the sorted versions. If they match, the strings are anagrams.

Pros:

• Easy to understand and implement.

Cons:

• Sorting takes O(n log n) time, which can be slow for large strings.

Solution 2: Frequency Count Using HashMap

Instead of sorting, we can count the frequency of each character in both strings and compare the frequencies. This is a more efficient approach in terms of time complexity.

Steps:

1. Create a frequency map (or counter) for both strings.
2. Compare the frequency maps.

Code Example:

import java.util.HashMap;

public class CheckAnagram2 {
    public static boolean areAnagrams(String str1, String str2) {
        // Remove spaces and convert to lowercase
        str1 = str1.replaceAll("\\s", "").toLowerCase();
        str2 = str2.replaceAll("\\s", "").toLowerCase();

        // Check if lengths are the same
        if (str1.length() != str2.length()) {
            return false;
        }

        // Create frequency maps for both strings
        HashMap<Character, Integer> charCountMap1 = getCharFrequencyMap(str1);
        HashMap<Character, Integer> charCountMap2 = getCharFrequencyMap(str2);

        // Compare the two maps
        return charCountMap1.equals(charCountMap2);
    }

    private static HashMap<Character, Integer> getCharFrequencyMap(String str) {
        HashMap<Character, Integer> charCountMap = new HashMap<>();
        for (char c : str.toCharArray()) {
            charCountMap.put(c, charCountMap.getOrDefault(c, 0) + 1);
        }
        return charCountMap;
    }

    public static void main(String[] args) {
        String str1 = "Triangle";
        String str2 = "Integral";

        if (areAnagrams(str1, str2)) {
            System.out.println(str1 + " and " + str2 + " are anagrams.");
        } else {
            System.out.println(str1 + " and " + str2 + " are not anagrams.");
        }
    }
}

Explanation:

• We use a HashMap to count the occurrences of each character in both strings.
• We then compare the two maps. If the maps are identical, the strings are anagrams.

Pros:

• More efficient than sorting, with a time complexity of O(n), where n is the length of the string.

Cons:

• Slightly more complex to implement than the sorting method.

Solution 3: Array Frequency Count

This solution uses an array of size 26 to count character frequencies (assuming the input only contains lowercase English letters). Each index in the array represents a letter, and we increment or decrement based on the characters in both strings.

Steps:

1. Initialize an array of size 26.
2. For each character in the first string, increment the corresponding index.
3. For each character in the second string, decrement the corresponding index.
4. If all values in the array are zero, the strings are anagrams.

Code Example:

public class CheckAnagram3 {
    public static boolean areAnagrams(String str1, String str2) {
        // Remove spaces and convert to lowercase
        str1 = str1.replaceAll("\\s", "").toLowerCase();
        str2 = str2.replaceAll("\\s", "").toLowerCase();

        // Check if lengths are the same
        if (str1.length() != str2.length()) {
            return false;
        }

        // Initialize an array for character counts
        int[] charCounts = new int[26];

        // Increment/decrement counts based on characters in the strings
        for (int i = 0; i < str1.length(); i++) {
            charCounts[str1.charAt(i) - 'a']++;
            charCounts[str2.charAt(i) - 'a']--;
        }

        // Check if all counts are zero
        for (int count : charCounts) {
            if (count != 0) {
                return false;
            }
        }

        return true;
    }

    public static void main(String[] args) {
        String str1 = "night";
        String str2 = "thing";

        if (areAnagrams(str1, str2)) {
            System.out.println(str1 + " and " + str2 + " are anagrams.");
        } else {
            System.out.println(str1 + " and " + str2 + " are not anagrams.");
        }
    }
}

Explanation:

• This solution efficiently counts the character frequencies using an integer array. It assumes input strings are made up of lowercase English letters.
• The array size is fixed (26), making this solution very efficient in terms of space and time.

Pros:

• Time complexity is O(n), and space complexity is O(1) due to the fixed array size.

Cons:

• Limited to lowercase alphabetic characters. You would need to adjust for special characters and upper case.

Funny Twist on Anagrams: “Palindrome’s Mischievous Cousin”

Anagrams are like palindromes’ fun-loving cousins. While a palindrome likes everything neat and symmetrical (because it reads the same forwards and backward), an anagram is more like a party — all the letters show up, but they’re free to move around and hang out in different spots. The trick to anagrams is making sure everyone still shows up, just in a different order!

Imagine telling someone, “Hey, let’s play Scrabble, but you can only use the letters from ‘silent’!” And boom, they come back with “listen.” Like Scrabble but with magic.

It’s the kind of party where “Debit Card” and “Bad Credit” are best buddies, and if you’re really cool, you’ll know that “The Eyes” equals “They See.”

Lastly

Anagrams may sound simple, but their applications are vast, from games and puzzles to serious data analysis tasks. In Java, there are various ways to check for anagrams — from sorting to using HashMap or even an array for counting character frequencies. Each method has its trade-offs in terms of time complexity, space complexity, and ease of implementation.

So next time you find yourself in an interview or a coding challenge, remember that anagrams are just word puzzles, and you’ve got the right tools in Java to solve them!

People Also Ask,

What is an anagram and how can it be implemented in Java?

An anagram is a word or phrase formed by rearranging the letters of another word or phrase. To implement it in Java, you can compare two strings by either sorting their characters and checking equality or by counting the frequency of each character in both strings. If both strings have the same length and same character frequencies, they are anagrams. One method to implement is sorting:

Arrays.sort(arr1);
Arrays.sort(arr2);
return Arrays.equals(arr1, arr2);

What are the steps to check if two strings are anagrams in Java?

1. Remove spaces and convert both strings to lowercase.
2. Ensure both strings have the same length.
3. Either:
   • Sort both strings and compare the sorted versions, or
   • Use a data structure like a HashMap to count the frequency of each character in both strings and compare the results. If all conditions are met, the strings are anagrams.

What is the most efficient way to check for anagrams in Java?

The most efficient way is using an array to count the frequency of characters. This solution operates with O(n) time complexity, where n is the length of the strings. For each character in the first string, increment the count, and for each character in the second string, decrement the count. If all counts are zero by the end, the strings are anagrams. This approach avoids the overhead of sorting.

Can we use a HashMap to check for anagrams in Java?

Yes, you can use a HashMap to count the frequency of each character in both strings. Here’s the approach:

1. Create a HashMap for both strings.
2. Iterate through the first string, counting each character’s occurrence.
3. Do the same for the second string.
4. Compare both maps. If they are identical, the strings are anagrams. Using a HashMap allows flexibility for checking strings that contain special characters or are case-sensitive.

Is there a difference between using sorting and using HashMap to check for anagrams?

Yes, there are differences in performance and use case:

• Sorting: This method is simple but has a time complexity of O(n log n) due to the sorting operation. It’s effective for small strings but can be slower for larger inputs.
• HashMap: This approach has a time complexity of O(n), making it more efficient for longer strings. It also handles cases where characters may be repeated in a more intuitive way. However, it uses additional memory for storing character frequencies.

Can an anagram contain spaces and punctuation in Java?

Yes, anagrams can contain spaces and punctuation, but when checking for anagrams in Java, we usually ignore spaces and punctuation. This is done by removing spaces and non-alphanumeric characters before comparison.

str1 = str1.replaceAll("\\s", "").replaceAll("\\p{Punct}", "").toLowerCase();
str2 = str2.replaceAll("\\s", "").replaceAll("\\p{Punct}", "").toLowerCase();

Can anagram checking be done in Java with Unicode characters?

Yes, Java supports Unicode, so you can check for anagrams with Unicode characters, such as accented letters or non-Latin scripts. You should ensure that both strings are normalized (using methods like java.text.Normalizer.normalize()) to prevent different Unicode representations of the same characters from being treated as different.

What are the limitations of the sorting method in checking anagrams?

The main limitation of the sorting method is its time complexity of O(n log n), which can be inefficient for very large strings. Additionally, it may not handle special characters or case sensitivity well without extra processing (e.g., converting everything to lowercase and removing non-alphabetical characters).

How do you handle case sensitivity when checking for anagrams in Java?

To handle case sensitivity, you should convert both strings to either all lowercase or all uppercase before comparing them.

str1 = str1.toLowerCase();
str2 = str2.toLowerCase();

Is there a difference between anagrams and palindromes?

Yes, anagrams and palindromes are different concepts:

• Anagrams involve rearranging the letters of a word or phrase to form another valid word or phrase.
• Palindromes are words or phrases that read the same forward and backward (e.g., “madam” or “racecar”). While both concepts deal with character manipulation, anagrams allow any order of letters, while palindromes require symmetry.

Can I check anagrams for phrases or sentences?

Yes, you can check for anagrams in phrases or sentences. In this case, spaces and punctuation are typically ignored. You can remove spaces and punctuation from the input strings, and then use one of the usual methods (sorting or frequency counting) to determine if the phrases are anagrams.

What are some real-world applications of anagram checking in Java?

Anagram checking has several real-world applications, including:

• Word games like Scrabble or crosswords where anagrams help identify valid words.
• Cryptography and data comparison where rearranged data must be detected.
• Natural language processing (NLP), where text analysis may involve detecting anagrams in large datasets or documents.

You also may like these,

All HackerRank Solutions in Java
Java Interview Preparation