Anagram Check Techniques in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Sorting-Based Anagram Check

What is the output of the following JavaScript code that checks if two strings are anagrams by sorting their characters?

DSA Javascript

function areAnagrams(str1, str2) {
  if (str1.length !== str2.length) return false;
  const sorted1 = str1.split('').sort().join('');
  const sorted2 = str2.split('').sort().join('');
  return sorted1 === sorted2;
}
console.log(areAnagrams('listen', 'silent'));
console.log(areAnagrams('hello', 'bello'));

A true\nfalse

B false\nfalse

C true\ntrue

D false\ntrue

💡 Hint

Think about what sorting the characters in both strings does and how it helps compare them.

Sorting both strings arranges their characters in order. If they are anagrams, the sorted strings will be identical. 'listen' and 'silent' are anagrams, so the first output is true. 'hello' and 'bello' differ in characters, so the second output is false.

❓ Predict Output

intermediate

Output of Frequency Map Anagram Check

What is the output of this JavaScript code that checks if two strings are anagrams using character frequency maps?

DSA Javascript

function areAnagrams(str1, str2) {
  if (str1.length !== str2.length) return false;
  const freq = {};
  for (const char of str1) {
    freq[char] = (freq[char] || 0) + 1;
  }
  for (const char of str2) {
    if (!freq[char]) return false;
    freq[char]--;
  }
  return true;
}
console.log(areAnagrams('triangle', 'integral'));
console.log(areAnagrams('apple', 'papel'));

A true\ntrue

B false\ntrue

C true\nfalse

D false\nfalse

💡 Hint

Check how the frequency map counts characters and how the second loop reduces counts.

Both 'triangle' and 'integral' have the same characters with the same counts, so true. Similarly, 'apple' and 'papel' are anagrams, so true again.

❓ Predict Output

advanced

Output of Case-Insensitive Anagram Check

What is the output of this JavaScript code that checks if two strings are anagrams ignoring case differences?

DSA Javascript

function areAnagrams(str1, str2) {
  if (str1.length !== str2.length) return false;
  const normalize = s => s.toLowerCase().split('').sort().join('');
  return normalize(str1) === normalize(str2);
}
console.log(areAnagrams('Dormitory', 'DirtyRoom'));
console.log(areAnagrams('Schoolmaster', 'TheClassroom'));

A false\nfalse

B false\ntrue

C true\nfalse

D true\ntrue

💡 Hint

Consider how converting to lowercase affects the comparison.

Converting both strings to lowercase before sorting makes the comparison case-insensitive. Both pairs are anagrams ignoring case, so both outputs are true.

❓ Predict Output

advanced

Output of Anagram Check with Unicode Characters

What is the output of this JavaScript code that checks if two strings with Unicode characters are anagrams?

DSA Javascript

function areAnagrams(str1, str2) {
  if (str1.length !== str2.length) return false;
  const freq = new Map();
  for (const char of str1) {
    freq.set(char, (freq.get(char) || 0) + 1);
  }
  for (const char of str2) {
    if (!freq.has(char) || freq.get(char) === 0) return false;
    freq.set(char, freq.get(char) - 1);
  }
  return true;
}
console.log(areAnagrams('résumé', 'sérumé'));
console.log(areAnagrams('café', 'face'));

A false\ntrue

B true\ntrue

C true\nfalse

D false\nfalse

💡 Hint

Unicode characters are treated as single characters in JavaScript strings.

'résumé' and 'sérumé' have the same characters with the same counts, so true. 'café' and 'face' differ in characters, so false.

🧠 Conceptual

expert

Time Complexity of Anagram Check Methods

Which statement correctly describes the time complexity of the two common anagram check methods: sorting-based and frequency map-based?

A Sorting-based method is O(n), frequency map method is O(n log n)

B Sorting-based method is O(n log n), frequency map method is O(n)

C Both methods have O(n log n) time complexity

D Both methods have O(n) time complexity

💡 Hint

Consider the cost of sorting versus counting characters.

Sorting characters takes O(n log n) time, while building and checking frequency maps takes O(n) time, where n is the string length.

Practice

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

easy

A. They have the same length but different characters

B. They start with the same letter

C. They contain the same characters in any order

D. They have no characters in common

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 C

4. Quick Check:

   Anagrams = same characters [OK]

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

Common Mistakes:

• Thinking same length means anagrams
• Assuming same first letter means anagrams
• Ignoring character counts

2. Which of the following JavaScript code snippets correctly checks if two strings are anagrams by sorting?

easy

A. const areAnagrams = (a, b) => a.split('').sort() === b.split('').sort();

B. const areAnagrams = (a, b) => a.split().sort().join() === b.split().sort().join();

C. const areAnagrams = (a, b) => a.sort() === b.sort();

D. const areAnagrams = (a, b) => a.split('').sort().join('') === b.split('').sort().join('');

Solution

1. Step 1: Understand string and array methods

   Strings need to be split into arrays to sort, then joined back to strings for comparison.

2. Step 2: Check each option's correctness

   const areAnagrams = (a, b) => a.split('').sort().join('') === b.split('').sort().join(''); correctly splits, sorts, and joins both strings before comparing. const areAnagrams = (a, b) => a.split('').sort() === b.split('').sort(); compares arrays directly (wrong). const areAnagrams = (a, b) => a.sort() === b.sort(); tries to sort strings directly (invalid). const areAnagrams = (a, b) => a.split().sort().join() === b.split().sort().join(); uses split() without argument and join() without argument, which is incorrect.

3. Final Answer:

   const areAnagrams = (a, b) => a.split('').sort().join('') === b.split('').sort().join(''); -> Option D

4. Quick Check:

   Split + sort + join = correct syntax [OK]

Hint: Remember to join sorted arrays before comparing strings [OK]

Common Mistakes:

• Comparing arrays directly with ===
• Not joining arrays back to strings
• Using split() without arguments

3. What will be the output of the following code?

function isAnagram(s1, s2) {
  if (s1.length !== s2.length) return false;
  const count = {};
  for (const char of s1) {
    count[char] = (count[char] || 0) + 1;
  }
  for (const char of s2) {
    if (!count[char]) return false;
    count[char]--;
  }
  return true;
}
console.log(isAnagram('listen', 'silent'));
console.log(isAnagram('hello', 'bello'));

medium

A. true false

B. false true

C. true true

D. false false

Solution

1. Step 1: Analyze the first call isAnagram('listen', 'silent')

   Both strings have same length. Counting characters in 'listen' and subtracting counts for 'silent' matches perfectly, so returns true.

2. Step 2: Analyze the second call isAnagram('hello', 'bello')

   Strings have same length but 'hello' has 'h' which 'bello' does not. The count check fails and returns false.

3. Final Answer:

   true false -> Option A

4. Quick Check:

   Matching counts = true, mismatch = false [OK]

Hint: Count chars in first, subtract in second, check zero [OK]

Common Mistakes:

• Ignoring length check
• Not decrementing counts properly
• Returning true too early

4. The following code is intended to check if two strings are anagrams. What is the bug?

function checkAnagram(a, b) {
  const map = new Map();
  for (let i = 0; i < a.length; i++) {
    map.set(a[i], (map.get(a[i]) || 0) + 1);
    map.set(b[i], (map.get(b[i]) || 0) - 1);
  }
  for (const val of map.values()) {
    if (val !== 0) return false;
  }
  return true;
}

medium

A. It incorrectly updates counts for both strings in the same loop

B. It does not check string lengths before processing

C. It uses Map instead of a plain object which is invalid

D. It forgets to return true at the end

Solution

1. Step 1: Identify missing length check

   The code lacks an initial check to ensure both strings have the same length.

2. Step 2: Understand the impact of missing length check

   If `a.length < b.length`, the loop only iterates `a.length` times, incrementing counts for all of `a` but decrementing only the first `a.length` characters of `b`. Extra characters in `b` are ignored, potentially returning `true` incorrectly. Example: `checkAnagram('ab', 'abc')` balances 'a' and 'b' but ignores 'c', wrongly returns `true`. If `a` longer, it may detect mismatch via extra increments or `undefined` key.

3. Final Answer:

   It does not check string lengths before processing -> Option B

4. Quick Check:

   Missing length check = false positives [OK]

Hint: Check lengths first, then count characters [OK]

Common Mistakes:

• Updating counts for both strings simultaneously
• Assuming Map is invalid in JS
• Missing length check

5. You want to check if two strings are anagrams ignoring spaces and case. Which approach correctly implements this in JavaScript?

function isAnagramAdvanced(s1, s2) {
  // Fill in the blanks
}

hard

A. Normalize strings by removing spaces and lowercasing, then compare sorted characters

B. Compare lengths directly after trimming spaces only

C. Use a Map to count characters but ignore case and spaces only in one string

D. Check if s1 includes s2 ignoring case and spaces

Solution

1. Step 1: Normalize both strings

   Remove all spaces and convert both strings to lowercase to ignore case and spaces.

2. Step 2: Sort and compare normalized strings

   Sort the characters of both normalized strings and compare them to check if they are anagrams.

3. Final Answer:

   Normalize strings by removing spaces and lowercasing, then compare sorted characters -> Option A

4. Quick Check:

   Normalize + sort + compare = correct approach [OK]

Hint: Clean strings first, then sort and compare [OK]

Common Mistakes:

• Ignoring spaces in one string only
• Comparing lengths without normalization
• Using includes() which is incorrect for anagrams