Add explanation and solution for LeetCode problem 242 (Valid Anagram)

Author: romankurnovskii

explanations/242/en.md

@@ -0,0 +1,101 @@
+## 242. Valid Anagram [Easy]
+
+https://leetcode.com/problems/valid-anagram
+
+## Description
+Given two strings `s` and `t`, return `true` if `t` is an [anagram](https://en.wikipedia.org/wiki/Anagram) of `s`, and `false` otherwise.
+
+**Examples**
+
+```tex
+Example 1:
+Input: s = "anagram", t = "nagaram"
+Output: true
+
+Example 2:
+Input: s = "rat", t = "car"
+Output: false
+```
+
+**Constraints**
+```tex
+- 1 <= s.length, t.length <= 5 * 10^4
+- s and t consist of lowercase English letters
+```
+
+**Follow up:** What if the inputs contain Unicode characters? How would you adapt your solution to such a case?
+
+## Explanation
+
+### Strategy
+Let's restate the problem: You're given two strings, and you need to determine if one is an anagram of the other. An anagram is a word or phrase formed by rearranging the letters of another word or phrase, using all the original letters exactly once.
+
+This is a **character counting problem** that can be solved using hash tables to track the frequency of each character in both strings.
+
+**What is given?** Two strings `s` and `t` of potentially different lengths.
+
+**What is being asked?** Determine if `t` is an anagram of `s`.
+
+**Constraints:** The strings can be up to 50,000 characters long and contain only lowercase English letters.
+
+**Edge cases:** 
+- Strings of different lengths
+- Empty strings
+- Strings with repeated characters
+- Strings with all identical characters
+
+**High-level approach:**
+The solution involves counting the frequency of each character in both strings and comparing them. If the character counts match exactly, the strings are anagrams.
+
+**Decomposition:**
+1. **Check length equality**: If strings have different lengths, they can't be anagrams
+2. **Count characters in first string**: Use a hash table to track character frequencies
+3. **Decrement counts for second string**: For each character in the second string, decrement its count
+4. **Verify all counts are zero**: If any count is not zero, the strings are not anagrams
+
+**Brute force vs. optimized strategy:**
+- **Brute force**: Try all possible permutations of one string. This takes O(n!) time.
+- **Optimized**: Use character counting with hash tables. This takes O(n) time.
+
+### Steps
+Let's walk through the solution step by step using the first example: `s = "anagram"`, `t = "nagaram"`
+
+**Step 1: Check string lengths**
+- `s.length = 7`, `t.length = 7`
+- Lengths match ✓
+
+**Step 2: Initialize character count dictionary**
+- `char_count = {}`
+
+**Step 3: Count characters in first string (s)**
+- `s = "anagram"`
+- `char_count['a'] = 3` (appears 3 times)
+- `char_count['n'] = 1` (appears 1 time)
+- `char_count['g'] = 1` (appears 1 time)
+- `char_count['r'] = 1` (appears 1 time)
+- `char_count['m'] = 1` (appears 1 time)
+
+**Step 4: Decrement counts for second string (t)**
+- `t = "nagaram"`
+- `t[0] = 'n'`: `char_count['n'] = 1 - 1 = 0`
+- `t[1] = 'a'`: `char_count['a'] = 3 - 1 = 2`
+- `t[2] = 'g'`: `char_count['g'] = 1 - 1 = 0`
+- `t[3] = 'a'`: `char_count['a'] = 2 - 1 = 1`
+- `t[4] = 'r'`: `char_count['r'] = 1 - 1 = 0`
+- `t[5] = 'a'`: `char_count['a'] = 1 - 1 = 0`
+- `t[6] = 'm'`: `char_count['m'] = 1 - 1 = 0`
+
+**Step 5: Verify all counts are zero**
+- All character counts are now 0
+- The strings are anagrams: `true`
+
+**Why this works:**
+By counting characters in the first string and then decrementing for the second string, we ensure that:
+1. Both strings contain the same characters
+2. Each character appears the same number of times in both strings
+3. The final count of 0 for all characters confirms the anagram property
+
+> **Note:** The key insight is using character frequency counting to verify that both strings contain exactly the same characters with the same frequencies. This is much more efficient than trying to find permutations.
+
+**Time Complexity:** O(n) - we visit each character once in each string  
+**Space Complexity:** O(k) - where k is the number of unique characters (bounded by the character set size)

solutions/242/01.py

@@ -0,0 +1,39 @@
+def isAnagram(s, t):
+    """
+    Determine if two strings are anagrams of each other.
+    
+    Args:
+        s: str - First string
+        t: str - Second string
+        
+    Returns:
+        bool - True if strings are anagrams, False otherwise
+    """
+    # Check if strings have different lengths
+    if len(s) != len(t):
+        return False
+    
+    # Create character count dictionary
+    char_count = {}
+    
+    # Count characters in first string
+    for char in s:
+        char_count[char] = char_count.get(char, 0) + 1
+    
+    # Decrement counts for characters in second string
+    for char in t:
+        if char not in char_count:
+            return False
+        
+        char_count[char] -= 1
+        
+        # If count becomes negative, strings are not anagrams
+        if char_count[char] < 0:
+            return False
+    
+    # Check if all counts are zero
+    for count in char_count.values():
+        if count != 0:
+            return False
+    
+    return True