Valid Anagram - CA14

My Thinking and Approach

Introduction

In this problem, I was given two strings and asked to check whether one string is an anagram of the other.

An anagram means both strings contain the same characters with the same frequency but possibly in a different order.

Problem Statement

• Given two strings s and t




• Return true if t is an anagram of s




• Otherwise return false



• 
  

  Conditions:

  
  
  
  
  
  • Strings contain only lowercase English letters
  
  
  
  
  
  

My Initial Thought

At first, I considered:

• Sorting both strings


• Comparing them

If both sorted strings are equal, then they are anagrams.

Key Observation

Instead of sorting:

• I can count frequency of each character


• Compare frequencies of both strings

Optimized Approach

I decided to:

• Use a dictionary to count characters


• Compare counts

Logic:

• If lengths are not equal → return false


• Count characters of first string


• Decrease count using second string


• If all counts become zero → valid anagram

My Approach (Step-by-Step)

1. If length of s and t are not equal → return false


2. Create a dictionary count


3. Traverse string s:

• 
  

  Increase count of each character

  
  
  
  
  
  1. Traverse string t:
  
  
  
  



• Decrease count of each character



• 
  

  If any count becomes negative → return false

  
  
  
  
  
  1. If all counts are zero → return true
  
  
  
  

Code (Python)

Below is the implementation clearly separated inside a code block:

```python id="t3q4xz"

class Solution:

def isAnagram(self, s, t):

if len(s) != len(t):

return False

    count = {}



    for ch in s:

        count[ch] = count.get(ch, 0) + 1



    for ch in t:

        if ch not in count or count[ch] == 0:

            return False

        count[ch] -= 1



    return True

---



## Example Walkthrough



### Input:







```text id="h8u9dn"

s = "anagram", t = "nagaram"

Steps:

• Count characters in s


• Reduce counts using t


• All counts become zero

Output:

```text id="9pkz0y"

true

---



## Complexity Analysis



| Type             | Complexity |

| ---------------- | ---------- |

| Time Complexity  | O(n)       |

| Space Complexity | O(1)       |



---



## Key Takeaways



* Sorting is simple but not optimal

* Frequency counting is efficient

* Hashmap helps in tracking characters



---



## Conclusion



This problem helped me understand how to efficiently check anagrams using character frequency instead of sorting.



---