ANAGRAMS

How I Understood Checking Anagrams in Python (LeetCode 242)
When I first saw this problem, it looked like it might require sorting or multiple passes, but after thinking about it, I realized it can be solved efficiently with frequency counting.

Problem
Given two strings s and t, determine if t is an anagram of s.
An anagram means both strings contain the same characters with the same frequency, but possibly in a different order.
Examples:
Python
s = "anagram"
t = "nagaram"

Output: True

Python
s = "rat"
t = "car"

Output: False

** What I Noticed**
Instead of sorting both strings (O(n log n)), I focused on:
Counting how many times each character appears in s
Subtracting counts based on characters in t
If all counts are zero at the end, the strings are anagrams
This approach is linear time O(n) and uses minimal extra space.

**What Helped Me
**Using a single frequency dictionary worked perfectly:
Check lengths first: If lengths differ, they can’t be anagrams
Count characters:
Add for s
Subtract for t
Check all counts: If any value isn’t zero, return False
This combines counting for both strings in one pass, making it efficient.

Code (Python)
Python
class Solution:
def isAnagram(self, s: str, t: str) -> bool:
# Step 1: Base case - different lengths cannot be anagrams
if len(s) != len(t):
return False

    # Step 2: Initialize frequency dictionary
    count = {}

    for i in range(len(s)):
        # Increment count for string s
        count[s[i]] = count.get(s[i], 0) + 1
        # Decrement count for string t
        count[t[i]] = count.get(t[i], 0) - 1

    # Step 3: Check if all values are zero
    for val in count.values():
        if val != 0:
            return False

    return True

** Example Usage**
Python
s = "anagram"
t = "nagaram"
solution = Solution()
print(solution.isAnagram(s, t))
Output:
Plain text
True

Complexity
Time: O(n) — iterate through both strings once
Space: O(1) — at most 26 keys for lowercase letters (or O(n) in general for all characters)

What I Learned
This problem shows that thinking in terms of frequency counting is often more efficient than sorting.
Check lengths first
Use one dictionary for both strings
One pass is enough to verify anagrams

Final Thought
At first, I thought this problem required sorting.
Once I realized:
“Count characters for s and subtract counts for t”
…it became clean and intuitive.
This is a great example of clever use of hash maps for string problems.