Frequency Counter Pattern Using Hash Map in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Frequency Counter for Characters

What is the output of the following TypeScript code that counts character frequencies in a string?

DSA Typescript

function charFrequency(str: string): Record<string, number> {
  const freq: Record<string, number> = {};
  for (const char of str) {
    freq[char] = (freq[char] || 0) + 1;
  }
  return freq;
}

console.log(charFrequency("hello"));

A {"h":1,"e":2,"l":2,"o":1}

B {"h":1,"e":1,"l":1,"o":1}

C {"h":1,"e":1,"l":3,"o":1}

D {"h":1,"e":1,"l":2,"o":1}

💡 Hint

Count how many times each letter appears in the word "hello".

The function counts each character's occurrences. 'l' appears twice, others once.

❓ Predict Output

intermediate

Frequency Counter for Numbers in Array

What will be printed after running this TypeScript code that counts frequencies of numbers in an array?

DSA Typescript

function numFrequency(arr: number[]): Record<number, number> {
  const freq: Record<number, number> = {};
  for (const num of arr) {
    freq[num] = (freq[num] || 0) + 1;
  }
  return freq;
}

console.log(numFrequency([1,2,2,3,3,3]));

A {"1":1,"2":3,"3":2}

B {"1":1,"2":2,"3":3}

C {"1":1,"2":1,"3":1}

D {"1":2,"2":2,"3":2}

💡 Hint

Count how many times each number appears in the array.

Number 1 appears once, 2 appears twice, and 3 appears three times.

🧠 Conceptual

advanced

Why Use Frequency Counter Pattern?

Which of the following best explains why the frequency counter pattern using a hash map is efficient for comparing two arrays for the same frequency of elements?

A It allows counting elements in linear time and comparing counts quickly without nested loops.

B It uses recursion to count elements in both arrays simultaneously.

C It sorts both arrays first to compare elements one by one.

D It converts arrays to strings and compares the strings directly.

💡 Hint

Think about how hash maps store counts and how that helps avoid repeated scanning.

Frequency counters store counts in a hash map, enabling O(n) time comparison without nested loops.

🔧 Debug

advanced

Identify the Bug in Frequency Counter Code

What will this TypeScript code output when counting character frequencies?

DSA Typescript

function freqCounter(str: string): Record<string, number> {
  const freq: Record<string, number> = {};
  for (let i = 0; i < str.length; i++) {
    const char = str[i];
    freq[char] = (freq[char] || 0) + 1;
  }
  return freq;
}

console.log(freqCounter("abc"));

A ReferenceError: freq is not defined

B SyntaxError: Unexpected token

C {"a":1,"b":1,"c":1}

D {"a":1,"b":1,"c":1,"undefined":1}

💡 Hint

Check the loop boundary and what happens when index equals string length.

The loop boundary was off-by-one, causing an extra count for 'undefined'. Fixed to i < str.length to avoid this.

🚀 Application

expert

Frequency Counter to Check Anagrams

Given two strings, which option correctly uses frequency counters to check if they are anagrams (same letters with same counts)?

DSA Typescript

function areAnagrams(str1: string, str2: string): boolean {
  if (str1.length !== str2.length) return false;
  const freq1: Record<string, number> = {};
  const freq2: Record<string, number> = {};
  for (const char of str1) {
    freq1[char] = (freq1[char] || 0) + 1;
  }
  for (const char of str2) {
    freq2[char] = (freq2[char] || 0) + 1;
  }
  for (const key in freq1) {
    if (freq1[key] !== freq2[key]) return false;
  }
  return true;
}

console.log(areAnagrams("listen", "silent"));

A true

B false

C TypeError

D undefined

💡 Hint

Anagrams have the same frequency of each character.

The function counts characters in both strings and compares counts; 'listen' and 'silent' match.

Practice

1. What is the main purpose of using a frequency counter pattern with a hash map in algorithms?

easy

A. To reverse the order of elements in an array

B. To count how many times each item appears in a collection

C. To remove duplicate items from a list

D. To sort the items in ascending order

Solution

1. Step 1: Understand frequency counting

   The frequency counter pattern counts occurrences of each item in a collection.

2. Step 2: Recognize hash map usage

   A hash map stores each item as a key and its count as the value for quick lookup.

3. Final Answer:

   To count how many times each item appears in a collection -> Option B

4. Quick Check:

   Frequency counter = count items [OK]

Hint: Frequency counter counts occurrences using keys [OK]

Common Mistakes:

• Confusing frequency counting with sorting
• Thinking it removes duplicates instead of counting
• Assuming it reverses arrays

2. Which of the following TypeScript code snippets correctly initializes an empty frequency counter using a hash map?

easy

A. const freq = new Set();

B. const freq = [];

C. const freq: Record = {};

D. const freq = 0;

Solution

1. Step 1: Identify correct hash map initialization

   In TypeScript, an object with string keys and number values is used for frequency counting.

2. Step 2: Check each option

   const freq: Record = {}; uses Record = {} which is correct. Others are array, set, or number, which are incorrect for frequency counting.

3. Final Answer:

   const freq: Record = {}; -> Option C

4. Quick Check:

   Empty object for frequency map [OK]

Hint: Use object or map for frequency counters [OK]

Common Mistakes:

• Using array or set instead of object
• Initializing frequency counter as a number
• Not specifying key-value structure

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

const arr = ['a', 'b', 'a', 'c', 'b', 'a'];
const freq: Record = {};
for (const char of arr) {
  freq[char] = (freq[char] || 0) + 1;
}
console.log(freq);

medium

A. {"a": 3, "b": 2, "c": 1}

B. {"a": 1, "b": 1, "c": 1}

C. [3, 2, 1]

D. Error: freq is not iterable

Solution

1. Step 1: Loop through array and count frequencies

   Each character's count is incremented in freq. 'a' appears 3 times, 'b' 2 times, 'c' 1 time.

2. Step 2: Output the freq object

   console.log prints the object with counts: {"a": 3, "b": 2, "c": 1}.

3. Final Answer:

   {"a": 3, "b": 2, "c": 1} -> Option A

4. Quick Check:

   Count each char correctly [OK]

Hint: Increment count or start at zero for each key [OK]

Common Mistakes:

• Printing array instead of object
• Not initializing counts to zero
• Trying to iterate freq as array

4. Identify the error in the following TypeScript code that tries to count character frequencies:

const str = "hello";
const freq: Record = {};
for (let i = 0; i <= str.length; i++) {
  const char = str[i];
  freq[char] = (freq[char] || 0) + 1;
}
console.log(freq);

medium

A. freq should be initialized as an array, not object

B. The code is correct and will run without errors

C. char variable should be declared outside the loop

D. Loop condition should be i < str.length, not i <= str.length

Solution

1. Step 1: Check loop boundary

   The loop runs from i = 0 to i <= str.length, which accesses str[str.length] (undefined).

2. Step 2: Fix loop condition

   Change condition to i < str.length to avoid accessing undefined character.

3. Final Answer:

   Loop condition should be i < str.length, not i <= str.length -> Option D

4. Quick Check:

   Loop index must be less than length [OK]

Hint: Use < length, not <= length in loops [OK]

Common Mistakes:

• Using <= instead of < in loop condition
• Initializing freq as array instead of object
• Declaring variables outside loop unnecessarily

5. Given two arrays of numbers, arr1 and arr2, which TypeScript function correctly uses the frequency counter pattern to check if arr2 contains the squares of all elements in arr1 with the same frequency?

hard

A. function sameFrequency(arr1: number[], arr2: number[]): boolean {
const freq1: Record = {};
const freq2: Record = {};
for (const num of arr1) freq1[num] = (freq1[num] || 0) + 1;
for (const num of arr2) freq2[num] = (freq2[num] || 0) + 1;
for (const key in freq1) {
if (freq2[Number(key) ** 2] !== freq1[key]) return false;
}
return true;
}

B. function sameFrequency(arr1: number[], arr2: number[]): boolean {
const freq1: Record = {};
for (const num of arr1) freq1[num] = (freq1[num] || 0) + 1;
for (const num of arr2) {
if (!freq1[num * num]) return false;
}
return true;
}

C. function sameFrequency(arr1: number[], arr2: number[]): boolean {
return arr1.length === arr2.length;
}

D. function sameFrequency(arr1: number[], arr2: number[]): boolean {
const freq1 = new Map();
for (const num of arr1) freq1.set(num, (freq1.get(num) || 0) + 1);
for (const num of arr2) {
if (!freq1.has(num * num)) return false;
}
return true;
}

Solution

1. Step 1: Build frequency maps for both arrays

   freq1 counts elements in arr1, freq2 counts elements in arr2.

2. Step 2: Check if freq2 has squares of keys in freq1 with same counts

   Loop over freq1 keys, verify freq2 has key squared with equal frequency.

3. Step 3: Return true if all match, else false

   If any mismatch found, return false; otherwise, return true.

4. Final Answer:

   Function in Option A correctly implements frequency counter for squares check -> Option A

5. Quick Check:

   Compare frequencies of numbers and their squares [OK]

Hint: Count frequencies, compare keys squared with same counts [OK]

Common Mistakes:

• Not comparing frequencies, only presence
• Checking squares incorrectly (num * num vs key squared)
• Ignoring frequency counts in second array