Check Anagram Java | Fresher Interview

Direct Answer

Two strings are anagrams if they contain the same characters with the same counts. The cleanest check is a frequency count: use an int[26] (lowercase letters), ++ for the first string, -- for the second, then verify every bucket is zero. That's O(n) time and O(1) space. Sorting both and comparing also works but is O(n log n).

Deep Dive & Architecture

Two strings are anagrams when they contain the same characters with the same frequencies, only in a different order. Equal length is the first quick check; strings of different lengths cannot be anagrams under the usual definition.

Worked example: listen and silent

Count every character in listen, then subtract the matching character while scanning silent. The final count for l, i, s, t, e, and n is zero, so the strings are anagrams. For listen and silence, the length check fails immediately.

For lowercase English letters, an array of 26 counters is the simplest solution. For a wider character set, use a HashMap<Character, Integer> or count Unicode code points. The important part is to state the input rules: should spaces be ignored, is matching case-sensitive, and should punctuation be removed? For example, Dormitory and dirty room match only after lowercasing and ignoring spaces.

Counting takes O(n) time. The extra space is O(1) for a fixed alphabet and O(k) for a map with k distinct characters. Sorting both strings is also correct, but it takes O(n log n) and creates sorted copies because Java strings are immutable.

Code Example

boolean isAnagram(String a, String b) {
    if (a.length() != b.length()) return false;   // early exit
    int[] count = new int[26];
    for (int i = 0; i < a.length(); i++) {
        count[a.charAt(i) - 'a']++;   // count first string up
        count[b.charAt(i) - 'a']--;   // count second string down
    }
    for (int c : count) if (c != 0) return false;
    return true;
}

// a="listen", b="silent"
// after loop every bucket nets to 0 -> true
// a="rat", b="car": 'r','a' net 0 but 't'=+1,'c'=-1 -> false

Common Mistakes & Pitfalls

• No length check: different lengths can never be anagrams - check first to save work.
• Assuming 26 letters: int[26] only works for lowercase a-z; use a HashMap for mixed case, digits, or Unicode.
• Sorting unnecessarily: sorting is O(n log n); counting is O(n).
• Case/space sensitivity: decide up front whether 'Listen'/'Silent' or spaces count as equal.