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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of frequency count using unordered_map

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

DSA C++

std::string s = "banana";
std::unordered_map<char, int> freq;
for (char c : s) {
    freq[c]++;
}
for (auto &pair : freq) {
    std::cout << pair.first << ":" << pair.second << " ";
}

A b:2 a:3 n:1

B a:3 b:1 n:2

C a:2 b:1 n:3

D b:1 a:3 n:2

💡 Hint

Remember unordered_map does not guarantee order, but the counts are fixed.

The string "banana" has 1 'b', 3 'a's, and 2 'n's. The output prints each character and its count. The order may vary but the counts must match.

🧠 Conceptual

intermediate

Frequency Counter Pattern Purpose

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

A To reverse the order of elements in an array.

B To sort elements in ascending order using a hash map.

C To count how many times each element appears in a collection efficiently.

D To store elements in a linked list for sequential access.

💡 Hint

Think about what a hash map stores and how it helps count.

Frequency counter pattern uses a hash map to store elements as keys and their counts as values, enabling quick frequency lookup.

🔧 Debug

advanced

Identify the error in frequency counting code

What error does the following C++ code produce when counting frequencies of integers in a vector? std::vector nums = {1, 2, 2, 3}; std::unordered_map freq; for (int i = 0; i < nums.size(); i++) { freq[nums[i]] = freq[nums[i]] + 1; } std::cout << freq[4];

DSA C++

std::vector<int> nums = {1, 2, 2, 3};
std::unordered_map<int, int> freq;
for (int i = 0; i < nums.size(); i++) {
    freq[nums[i]] = freq[nums[i]] + 1;
}
std::cout << freq[4];

A Compilation error due to invalid syntax in freq access.

B Prints 0 because freq[4] is not set but default initializes to 0.

C Throws a runtime error because key 4 does not exist.

D Prints garbage value because freq[4] is uninitialized.

💡 Hint

Consider how unordered_map behaves when accessing a key that does not exist.

Accessing freq[4] inserts key 4 with default value 0, so printing freq[4] outputs 0 without error.

🚀 Application

advanced

Using frequency counter to check anagrams

Which code snippet correctly uses a frequency counter hash map to check if two strings are anagrams?

A

std::unordered_map<char, int> freq;
for (char c : s1) freq[c]++;
for (char c : s2) {
  if (--freq[c] < 0) return false;
}
return true;

B

std::unordered_map<char, int> freq;
for (char c : s1) freq[c]++;
for (char c : s2) freq[c]++;
return freq.empty();

C

std::unordered_map<char, int> freq;
for (char c : s1) freq[c]++;
for (char c : s2) freq[c]--;
return true;

D

std::unordered_map<char, int> freq;
for (char c : s1) freq[c]++;
for (char c : s2) {
  if (freq.find(c) == freq.end()) return false;
}
return true;

💡 Hint

Anagrams have the same character counts, so decrementing counts and checking negatives helps.

Option A increments counts for s1, then decrements for s2, returning false if any count goes negative, ensuring exact match.

❓ Predict Output

expert

Output of frequency counter with nested loops and map

What is the output of this C++ code that counts frequencies of integers and prints keys with frequency > 1?

DSA C++

std::vector<int> nums = {1, 2, 2, 3, 3, 3, 4};
std::map<int, int> freq;
for (int num : nums) {
    freq[num]++;
}
for (auto &pair : freq) {
    if (pair.second > 1) {
        std::cout << pair.first << ":" << pair.second << " ";
    }
}

A 2:2 3:3

B 1:1 2:2 3:3 4:1

C 3:3 2:2

D 2:3 3:2

💡 Hint

Only print numbers with frequency greater than 1, and map orders keys ascending.

Numbers 2 and 3 appear more than once with counts 2 and 3 respectively. Map prints keys in ascending order.

Practice

1. What is the main purpose of using a hash map in the Frequency Counter Pattern?

easy

A. To reverse the order of elements

B. To sort the elements in ascending order

C. To store elements without any duplicates

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

Solution

1. Step 1: Understand the role of a hash map

   A hash map stores key-value pairs, allowing quick lookup and update of counts.

2. Step 2: Apply to frequency counting

   We use the hash map keys as elements and values as their counts to track frequency.

3. Final Answer:

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

4. Quick Check:

   Frequency Counter = Counting elements [OK]

Hint: Hash map keys track elements, values track counts [OK]

Common Mistakes:

• Thinking hash map sorts elements
• Confusing frequency counting with removing duplicates
• Using hash map to reverse order

2. Which of the following is the correct syntax to declare a hash map in C++ to count frequencies of characters?

easy

A. std::vector<int> freq;

B. std::unordered_map freq;

C. std::unordered_set<char> freq;

D. std::map freq;

Solution

1. Step 1: Identify correct container for frequency counting

   We need a map from characters to integers to store counts.

2. Step 2: Check syntax correctness

   std::unordered_map freq; declares a hash map with char keys and int values.

3. Final Answer:

   std::unordered_map freq; -> Option B

4. Quick Check:

   unordered_map = frequency map [OK]

Hint: Use unordered_map for frequency counting [OK]

Common Mistakes:

• Using map with wrong key-value types
• Using unordered_set which stores only keys
• Using vector which is not a map

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

std::string s = "aabbcc";
std::unordered_map freq;
for (char c : s) {
    freq[c]++;
}
for (auto &p : freq) {
    std::cout << p.first << ":" << p.second << " ";
}

medium

A. a:2 b:2 c:2

B. a:1 b:1 c:1

C. a:3 b:3 c:3

D. a:2 b:3 c:1

Solution

1. Step 1: Count frequencies of each character in string

   Characters 'a', 'b', and 'c' each appear twice in "aabbcc".

2. Step 2: Print each character and its count

   The loop prints each character and its frequency, so output is "a:2 b:2 c:2 ".

3. Final Answer:

   a:2 b:2 c:2 -> Option A

4. Quick Check:

   Count 'a','b','c' = 2 each [OK]

Hint: Count each char's occurrences in string [OK]

Common Mistakes:

• Assuming counts are 1 instead of 2
• Mixing counts between characters
• Confusing output format

4. Identify the error in this C++ code snippet that tries to count frequencies of integers in a vector:

std::vector<int> nums = {1, 2, 2, 3};
std::unordered_map freq;
for (int i = 0; i < nums.size(); i++) {
    freq[nums[i]] = freq[nums[i]] + 1;
}
for (auto p : freq) {
    std::cout << p.first << ":" << p.second << " ";
}

medium

A. Loop should use range-based for instead of index

B. Using freq[nums[i]] = freq[nums[i]] + 1; causes runtime error

C. No error; code works correctly

D. freq should be declared as std::unordered_set<int>

Solution

1. Step 1: Check frequency counting logic

   freq[nums[i]] = freq[nums[i]] + 1; correctly increments count for each element.

2. Step 2: Verify container types and loops

   Using index loop and unordered_map is valid and works as intended.

3. Final Answer:

   No error; code works correctly -> Option C

4. Quick Check:

   Increment freq with freq[key]++ works [OK]

Hint: freq[key]++ increments count safely [OK]

Common Mistakes:

• Thinking freq[key] = freq[key] + 1 causes error
• Confusing unordered_map with unordered_set
• Believing range-based for is mandatory

5. Given two strings s1 and s2, which approach using frequency counters correctly checks if s2 is an anagram of s1?

std::unordered_map freq1, freq2;
for (char c : s1) freq1[c]++;
for (char c : s2) freq2[c]++;
// What next?

hard

A. Compare freq1 and freq2 maps for equality

B. Check if freq1 contains all keys of freq2 only

C. Check if freq2 has more keys than freq1

D. Sort s1 and s2 and compare strings

Solution

1. Step 1: Build frequency maps for both strings

   freq1 and freq2 store counts of each character in s1 and s2 respectively.

2. Step 2: Compare frequency maps for exact match

   If freq1 and freq2 are equal, s2 is an anagram of s1 because they have same chars with same counts.

3. Final Answer:

   Compare freq1 and freq2 maps for equality -> Option A

4. Quick Check:

   Anagram check = freq maps equal [OK]

Hint: Anagrams have identical frequency maps [OK]

Common Mistakes:

• Only checking keys without counts
• Assuming more keys means anagram
• Using sorting instead of frequency maps