Frequency Counter Pattern Using Hash Map in DSA Javascript - Time & Space Complexity

Time Complexity: Frequency Counter Pattern Using Hash Map

O(n)

Understanding Time Complexity

We want to know how fast the frequency counter pattern runs when counting items.

How does the time grow as the list gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

function frequencyCounter(arr) {
  const freq = {};
  for (const item of arr) {
    freq[item] = (freq[item] || 0) + 1;
  }
  return freq;
}
    

This code counts how many times each item appears in the list.

Identify Repeating Operations

• Primary operation: One loop over the array items.
• How many times: Exactly once for each item in the array.

How Execution Grows With Input

As the list gets bigger, the loop runs more times, once per item.

Input Size (n)	Approx. Operations
10	About 10 steps
100	About 100 steps
1000	About 1000 steps

Pattern observation: The work grows directly with the number of items.

Final Time Complexity

Time Complexity: O(n)

This means the time to count frequencies grows in a straight line with the list size.

Common Mistake

[X] Wrong: "Using a hash map makes the code slower because of extra steps."

[OK] Correct: The hash map lets us count items in one pass, so it actually saves time compared to checking each item multiple times.

Interview Connect

Knowing how to count items quickly is a key skill. It shows you can use simple tools to solve problems efficiently.

Self-Check

"What if we used nested loops to count frequencies instead of a hash map? How would the time complexity change?"

Practice

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

easy

A. To reverse the order of elements in an array

B. To sort the elements in ascending order

C. To remove duplicate items from a list

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

Solution

1. Step 1: Understand frequency counter pattern

   The frequency counter pattern uses a hash map to store counts of each item in a collection.

2. Step 2: Identify the purpose

   Counting occurrences helps to quickly check how many times each item appears.

3. Final Answer:

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

4. Quick Check:

   Frequency counter = count items [OK]

Hint: Frequency counter counts items using a hash map [OK]

Common Mistakes:

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

2. Which of the following is the correct way to initialize an empty frequency counter object in JavaScript?

easy

A. const freq = [];

B. const freq = {};

C. const freq = null;

D. const freq = 0;

Solution

1. Step 1: Identify correct data structure for frequency counter

   A frequency counter uses an object (hash map) to store keys and counts.

2. Step 2: Choose correct initialization syntax

   In JavaScript, an empty object is created with curly braces {}.

3. Final Answer:

   const freq = {}; -> Option B

4. Quick Check:

   Empty object = {} [OK]

Hint: Use {} to create empty object for frequency counter [OK]

Common Mistakes:

• Using array [] instead of object {}
• Assigning null or 0 which are not objects
• Confusing object with other data types

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

const arr = ['a', 'b', 'a', 'c', 'b', 'a'];
const freq = {};
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. {"a": 2, "b": 3, "c": 1}

D. {"a": 3, "b": 3, "c": 1}

Solution

1. Step 1: Loop through array and count characters

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

2. Step 2: Construct final frequency object

   freq = {"a": 3, "b": 2, "c": 1} after loop ends.

3. Final Answer:

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

4. Quick Check:

   Count 'a' = 3, 'b' = 2, 'c' = 1 [OK]

Hint: Count each char incrementally using freq[char] = (freq[char]||0)+1 [OK]

Common Mistakes:

• Mixing counts of 'a' and 'b'
• Not initializing counts properly
• Using arrays instead of objects for counting

4. Identify the error in the following frequency counter code and select the fix:

const arr = ['x', 'y', 'x', 'z'];
const freq = {};
for (let i = 0; i < arr.length; i++) {
  freq[arr[i]] += 1;
}
console.log(freq);

medium

A. Initialize freq[arr[i]] to 0 before adding 1

B. Change for loop to for...of loop

C. Use freq.push(arr[i]) instead of freq[arr[i]]

D. Declare freq as an array instead of object

Solution

1. Step 1: Understand the error cause

   freq[arr[i]] is undefined initially, so adding 1 causes NaN.

2. Step 2: Fix by initializing count

   Set freq[arr[i]] = 0 if undefined before adding 1.

3. Final Answer:

   Initialize freq[arr[i]] to 0 before adding 1 -> Option A

4. Quick Check:

   Initialize before increment to avoid NaN [OK]

Hint: Always initialize count to 0 before incrementing [OK]

Common Mistakes:

• Trying to push to object as if array
• Ignoring undefined initial values
• Changing loop type unnecessarily

5. Given two arrays, arr1 = [1, 2, 2, 3] and arr2 = [2, 3, 3, 4], which code snippet correctly checks if arr2 contains the same frequency of elements as arr1 using the frequency counter pattern?

hard

A. const freq1 = {};
const freq2 = {};
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 (freq1[key] !== freq2[key]) return false;
}
return true;

B. const freq = {};
for (const num of arr1) freq[num] = 1;
for (const num of arr2) freq[num] = 0;
return Object.values(freq).every(v => v === 0);

C. const freq = {};
for (const num of arr1) freq[num] = (freq[num] || 0) + 1;
for (const num of arr2) freq[num] -= 1;
for (const key in freq) {
if (freq[key] !== 0) return false;
}
return true;

D. const freq1 = new Map();
const freq2 = new Map();
arr1.forEach(num => freq1.set(num, (freq1.get(num) || 0) + 1));
arr2.forEach(num => freq2.set(num, (freq2.get(num) || 0) + 1));
return [...freq1.entries()].every(([key, val]) => freq2.get(key) === val);

Solution

1. Step 1: Understand frequency comparison logic

   We must count frequencies in both arrays and compare counts for each element.

2. Step 2: Analyze each code snippet

   const freq = {}; for (const num of arr1) freq[num] = (freq[num] || 0) + 1; for (const num of arr2) freq[num] -= 1; for (const key in freq) { if (freq[key] !== 0) return false; } return true; This uses a single object: increments for arr1, decrements for arr2 (NaN for extras), checks all zero. Handles extras (NaN≠0), shortages (positive≠0), overcounts (negative≠0).

3. Final Answer:

   const freq = {}; increment arr1, decrement arr2, check all zero -> Option C

4. Quick Check:

   Single freq: +arr1, -arr2, all zero? [OK]

Hint: Increment arr1 counts, decrement arr2, check all zero for same frequency [OK]

Common Mistakes:

• Not comparing all keys in both frequency counters
• Overwriting counts instead of incrementing
• Using single frequency object incorrectly