Anagram Check Techniques in DSA Typescript

Mental Model

Two words are anagrams if they have the exact same letters in the same amounts, just mixed differently.

Analogy: Imagine two bags of colored beads. If both bags have the same number of beads of each color, they are anagrams, even if the beads are arranged differently inside.

word1: c a t
word2: t a c

Both have letters: c, a, t but in different order.

Dry Run Walkthrough

Input: word1: "listen", word2: "silent"

Goal: Check if "listen" and "silent" are anagrams

Step 1: Count letters in "listen"

{"l":1, "i":1, "s":1, "t":1, "e":1, "n":1}

Why: We need to know how many times each letter appears in the first word

Step 2: Count letters in "silent"

{"s":1, "i":1, "l":1, "e":1, "n":1, "t":1}

Why: We count letters in the second word to compare with the first

Step 3: Compare both letter counts

Both counts match exactly

Why: If counts are the same, words are anagrams

Result:

Words are anagrams because letter counts match exactly

Annotated Code

DSA Typescript

class AnagramChecker {
  static areAnagrams(word1: string, word2: string): boolean {
    if (word1.length !== word2.length) return false; // quick length check

    const countLetters = (word: string): Record<string, number> => {
      const count: Record<string, number> = {};
      for (const char of word) {
        count[char] = (count[char] ?? 0) + 1; // count each letter
      }
      return count;
    };

    const count1 = countLetters(word1);
    const count2 = countLetters(word2);

    for (const char in count1) {
      if (count1[char] !== count2[char]) return false; // mismatch found
    }

    return true; // all counts match
  }
}

// Driver code
const word1 = "listen";
const word2 = "silent";
console.log(AnagramChecker.areAnagrams(word1, word2) ? "Anagrams" : "Not anagrams");

if (word1.length !== word2.length) return false; // quick length check

If lengths differ, words cannot be anagrams

for (const char of word) { count[char] = (count[char] ?? 0) + 1; }

Count each letter's occurrences in the word

for (const char in count1) { if (count1[char] !== count2[char]) return false; }

Compare letter counts between both words

return true; // all counts match

If no mismatch found, words are anagrams

Output

Anagrams

Complexity Analysis

Time: O(n) because we count letters in both words once, where n is word length

Space: O(1) because letter counts use fixed size storage (alphabet size), not growing with input

vs Alternative: Sorting approach takes O(n log n) time, so counting letters is faster and more efficient

Edge Cases

Empty strings

Returns true since both are empty and trivially anagrams

DSA Typescript

if (word1.length !== word2.length) return false;

Different lengths

Returns false immediately without counting letters

DSA Typescript

if (word1.length !== word2.length) return false;

Same letters but different counts (e.g., "aabb" vs "ababab")

Returns false because counts differ

DSA Typescript

if (count1[char] !== count2[char]) return false;

When to Use This Pattern

When you need to check if two words have the same letters in any order, use letter counting to quickly verify anagrams.

Common Mistakes

Mistake: Only sorting one word and comparing to the other without sorting it
Fix: Sort both words before comparing or use letter counting for both

Mistake: Not checking length first, causing unnecessary work
Fix: Add quick length check to return false early if lengths differ

Summary

Checks if two words have the same letters in the same amounts regardless of order.

Use when you want to verify if two strings are anagrams efficiently.

Counting letters and comparing counts is faster than sorting both words.

Practice

1. What does it mean if two strings are anagrams of each other?

easy

A. They contain the same characters in any order

B. They have the same length but different characters

C. They start with the same character

D. They end with the same character

Solution

1. Step 1: Understand the definition of anagrams

   Anagrams are words or phrases made by rearranging the letters of another, so they must have the same characters.

2. Step 2: Compare the character sets

   If two strings have exactly the same characters, just in different orders, they are anagrams.

3. Final Answer:

   They contain the same characters in any order -> Option A

4. Quick Check:

   Anagrams = same characters [OK]

Hint: Check if sorted strings match to confirm anagrams [OK]

Common Mistakes:

• Thinking same length means anagrams
• Only comparing first or last characters
• Ignoring character counts

2. Which TypeScript code snippet correctly checks if two strings are anagrams by sorting?

easy

A. const isAnagram = (a: string, b: string) => a.split('').sort().join('') === b.split('').sort().join('');

B. const isAnagram = (a: string, b: string) => a.split('').sort() === b.split('').sort();

C. const isAnagram = (a: string, b: string) => a.sort() === b.sort();

D. const isAnagram = (a: string, b: string) => a === b;

Solution

1. Step 1: Understand string sorting in TypeScript

   Strings must be split into arrays, sorted, then joined back to strings for comparison.

2. Step 2: Identify correct syntax

   const isAnagram = (a: string, b: string) => a.split('').sort().join('') === b.split('').sort().join(''); correctly splits, sorts, and joins both strings before comparing.

3. Final Answer:

   const isAnagram = (a: string, b: string) => a.split('').sort().join('') === b.split('').sort().join(''); -> Option A

4. Quick Check:

   Sort and join strings before compare [OK]

Hint: Always join after sorting arrays to compare strings [OK]

Common Mistakes:

• Comparing arrays directly without join
• Trying to sort strings directly
• Comparing strings without sorting

3. What is the output of this TypeScript code?

function areAnagrams(s1: string, s2: string): boolean {
  const normalize = (str: string) => str.toLowerCase().replace(/\s+/g, '').split('').sort().join('');
  return normalize(s1) === normalize(s2);
}

console.log(areAnagrams('Listen', 'Silent'));
console.log(areAnagrams('Hello', 'Olelh'));
console.log(areAnagrams('Test', 'Taste'));

medium

A. true false false

B. true true false

C. false true true

D. false false true

Solution

1. Step 1: Normalize strings by lowercasing, removing spaces, sorting

   'Listen' and 'Silent' normalize to 'eilnst', 'Hello' and 'Olelh' normalize to 'ehllo', 'Test' and 'Taste' normalize to 'estt' and 'aestt' respectively.

2. Step 2: Compare normalized strings

   'Listen' vs 'Silent' match (true), 'Hello' vs 'Olelh' match (true), 'Test' vs 'Taste' do not match (false).

3. Final Answer:

   true true false -> Option B

4. Quick Check:

   Normalized strings equal means true [OK]

Hint: Normalize strings before comparing for anagram check [OK]

Common Mistakes:

• Ignoring case differences
• Not removing spaces
• Not sorting characters

4. Identify the bug in this TypeScript function that checks anagrams:

function isAnagram(a: string, b: string): boolean {
  return a.split('').sort() === b.split('').sort();
}

medium

A. Not removing spaces before comparison

B. Missing toLowerCase() for case-insensitive check

C. Comparing arrays directly instead of strings

D. Using split() without arguments

Solution

1. Step 1: Understand array comparison in TypeScript

   Arrays compared with === check reference, not content, so two sorted arrays won't be equal even if same elements.

2. Step 2: Fix by joining arrays to strings before comparing

   Joining sorted arrays to strings allows content comparison, fixing the bug.

3. Final Answer:

   Comparing arrays directly instead of strings -> Option C

4. Quick Check:

   Arrays need join() before compare [OK]

Hint: Join sorted arrays before comparing for equality [OK]

Common Mistakes:

• Comparing arrays with ===
• Ignoring case sensitivity
• Not trimming spaces

5. Given two strings, how can you efficiently check if they are anagrams using a character count map in TypeScript? Which code snippet correctly implements this?

hard

A. function isAnagram(a: string, b: string): boolean {
if (a.length !== b.length) return false;
const count: Record = {};
for (const char of a) count[char] = (count[char] || 0) + 1;
for (const char of b) {
if (!count[char]) return false;
count[char]--;
}
return true;
}

B. function isAnagram(a: string, b: string): boolean {
return a.split('').sort().join('') === b.split('').sort().join('');
}

C. function isAnagram(a: string, b: string): boolean {
return a.length === b.length;
}

D. function isAnagram(a: string, b: string): boolean {
const mapA = new Map();
for (const c of a) mapA.set(c, (mapA.get(c) || 0) + 1);
for (const c of b) mapA.set(c, (mapA.get(c) || 0) - 1);
return [...mapA.values()].every(v => v === 0);
}

Solution

1. Step 1: Understand character count map approach

   Count characters in first string, subtract counts using second string, then check all counts zero.

2. Step 2: Analyze each option

   function isAnagram(a: string, b: string): boolean { if (a.length !== b.length) return false; const count: Record = {}; for (const char of a) count[char] = (count[char] || 0) + 1; for (const char of b) { if (!count[char]) return false; count[char]--; } return true; } misses checking if count goes negative; function isAnagram(a: string, b: string): boolean { return a.split('').sort().join('') === b.split('').sort().join(''); } uses sorting (correct but not map); function isAnagram(a: string, b: string): boolean { return a.length === b.length; } only checks length; function isAnagram(a: string, b: string): boolean { const mapA = new Map(); for (const c of a) mapA.set(c, (mapA.get(c) || 0) + 1); for (const c of b) mapA.set(c, (mapA.get(c) || 0) - 1); return [...mapA.values()].every(v => v === 0); } correctly uses Map to count and verify zero counts.

3. Final Answer:

   Option D correctly implements character count map with Map and zero check -> Option D

4. Quick Check:

   Map counts increment/decrement, all zero means anagram [OK]

Hint: Use map to count chars, decrement, then check all zero [OK]

Common Mistakes:

• Not checking for negative counts
• Only comparing lengths
• Using sorting instead of counting