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

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code using a frequency counter?

Consider the following Rust code that counts the frequency of characters in a string. What will be printed?

DSA Rust

use std::collections::HashMap;

fn main() {
    let text = "banana";
    let mut freq = HashMap::new();

    for ch in text.chars() {
        let count = freq.entry(ch).or_insert(0);
        *count += 1;
    }

    println!("{:?}", freq);
}

A {"a": 2, "b": 1, "n": 3}

B {"a": 3, "b": 1, "n": 2}

C {"b": 1, "n": 2, "a": 3}

D {"b": 1, "a": 3, "n": 2}

💡 Hint

Remember that HashMap does not guarantee order, but the counts must be correct.

The code counts each character's occurrences in the string "banana". 'b' appears once, 'a' appears three times, and 'n' appears twice. The printed HashMap shows these counts.

🧠 Conceptual

intermediate

How does the frequency counter pattern help in comparing two strings?

Why is using a frequency counter with a hash map useful when checking if two strings are anagrams?

A It removes duplicate characters from both strings before comparison.

B It counts characters in both strings to compare if they have the same frequency of each character.

C It sorts both strings alphabetically and compares them directly.

D It converts both strings to uppercase to ignore case differences.

💡 Hint

Think about what an anagram means in terms of character counts.

Anagrams have the same characters with the same frequency. Using a frequency counter helps count characters in both strings and compare these counts to confirm if they are anagrams.

🔧 Debug

advanced

What error does this Rust code produce when using a frequency counter?

Identify the error in this Rust code snippet that tries to count character frequencies and explain why it happens.

DSA Rust

use std::collections::HashMap;

fn main() {
    let text = "apple";
    let mut freq = HashMap::new();

    for ch in text.chars() {
        freq.insert(ch, freq[&ch] + 1);
    }

    println!("{:?}", freq);
}

A KeyError because freq[&ch] tries to access a key that may not exist yet.

B SyntaxError due to missing semicolon after freq.insert line.

C TypeError because freq.insert expects a string key but gets a char.

D No error; the code runs and prints the frequency correctly.

💡 Hint

Think about what happens when you try to access a key in a HashMap that is not present.

The code tries to access freq[&ch] before the key exists in the HashMap, causing a panic at runtime because the key is missing.

❓ Predict Output

advanced

What is the output of this Rust code counting word frequencies?

Given the following Rust code that counts word frequencies in a vector, what will be printed?

DSA Rust

use std::collections::HashMap;

fn main() {
    let words = vec!["cat", "dog", "cat", "bird", "dog", "dog"];
    let mut freq = HashMap::new();

    for word in words {
        let count = freq.entry(word).or_insert(0);
        *count += 1;
    }

    println!("{:?}", freq);
}

A {"cat": 2, "dog": 3, "bird": 1}

B {"dog": 3, "cat": 2, "bird": 1}

C {"bird": 1, "cat": 2, "dog": 3}

D {"cat": 3, "dog": 2, "bird": 1}

💡 Hint

Count how many times each word appears in the list.

The vector contains "cat" twice, "dog" three times, and "bird" once. The HashMap stores these counts.

🚀 Application

expert

How to efficiently check if two arrays have the same frequency of elements using Rust?

You have two integer arrays. Which Rust code snippet correctly uses a frequency counter pattern with HashMap to check if both arrays have the same frequency of elements?

A

fn same_frequency(arr1: &[i32], arr2: &[i32]) -> bool {
    let mut arr1 = arr1.to_vec();
    let mut arr2 = arr2.to_vec();
    arr1.sort();
    arr2.sort();
    arr1 == arr2
}

B

fn same_frequency(arr1: &[i32], arr2: &[i32]) -> bool {
    use std::collections::HashMap;
    if arr1.len() != arr2.len() { return false; }
    let mut freq1 = HashMap::new();
    let mut freq2 = HashMap::new();
    for &num in arr1 { *freq1.entry(num).or_insert(0) += 1; }
    for &num in arr2 { *freq2.entry(num).or_insert(0) += 1; }
    freq1 == freq2
}

C

fn same_frequency(arr1: &[i32], arr2: &[i32]) -> bool {
    use std::collections::HashMap;
    let mut freq = HashMap::new();
    for &num in arr1 { *freq.entry(num).or_insert(0) += 1; }
    for &num in arr2 { *freq.entry(num).or_insert(0) -= 1; }
    freq.values().all(|&v| v == 0)
}

D

fn same_frequency(arr1: &[i32], arr2: &[i32]) -> bool {
    use std::collections::HashSet;
    let set1: HashSet<_> = arr1.iter().collect();
    let set2: HashSet<_> = arr2.iter().collect();
    set1 == set2
}

💡 Hint

Think about counting frequencies in one map and adjusting counts with the second array.

Option C uses one HashMap to count frequencies from the first array and subtract frequencies from the second. If all counts return to zero, arrays have the same frequency of elements.

Practice

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

easy

A. To remove duplicate items from the collection

B. To sort the items in ascending order

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

D. To reverse the order of items in the collection

Solution

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

   A hash map stores key-value pairs, allowing quick lookup of counts for each item.

2. Step 2: Connect to frequency counting

   Using the hash map, we track how many times each item appears by updating counts.

3. Final Answer:

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

4. Quick Check:

   Frequency counting = Counting items [OK]

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

Common Mistakes:

• Thinking hash map sorts items
• Confusing frequency counting with removing duplicates
• Assuming hash map reverses order

2. Which of the following Rust code snippets correctly initializes an empty hash map for frequency counting?

easy

A. let mut freq = Vec::with_capacity(10);

B. let freq = Vec::new();

C. let freq = HashSet::new();

D. let mut freq = HashMap::new();

Solution

1. Step 1: Identify the correct data structure for frequency counting

   Frequency counting requires a hash map to store keys and counts.

2. Step 2: Check Rust syntax for hash map initialization

   In Rust, HashMap::new() creates an empty hash map; mut allows modification.

3. Final Answer:

   let mut freq = HashMap::new(); -> Option D

4. Quick Check:

   HashMap::new() initializes empty map [OK]

Hint: Use HashMap::new() with mut for frequency map [OK]

Common Mistakes:

• Using Vec or HashSet instead of HashMap
• Forgetting mut keyword to modify map
• Confusing capacity with initialization

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

use std::collections::HashMap;

fn main() {
    let items = vec!["apple", "banana", "apple", "orange", "banana", "apple"];
    let mut freq = HashMap::new();

    for item in items {
        let count = freq.entry(item).or_insert(0);
        *count += 1;
    }

    println!("{:?}", freq);
}

medium

A. {"apple": 1, "banana": 1, "orange": 1}

B. {"apple": 3, "banana": 2, "orange": 1}

C. {"apple": 2, "banana": 2, "orange": 2}

D. Compilation error due to missing mut

Solution

1. Step 1: Count occurrences of each fruit

   "apple" appears 3 times, "banana" 2 times, "orange" 1 time in the vector.

2. Step 2: Check how counts are updated in the hash map

   Each item increments its count correctly using entry and or_insert.

3. Final Answer:

   {"apple": 3, "banana": 2, "orange": 1} -> Option B

4. Quick Check:

   Count each fruit correctly = {"apple":3,"banana":2,"orange":1} [OK]

Hint: Count each item incrementally with entry().or_insert(0) [OK]

Common Mistakes:

• Assuming counts start at 1 instead of 0
• Forgetting to dereference count to increment
• Confusing output format or order

4. Identify the error in this Rust code snippet for frequency counting:

use std::collections::HashMap;

fn main() {
    let items = vec!["cat", "dog", "cat"];
    let mut freq = HashMap::new();

    for item in items {
        let count = freq.entry(item).or_insert(1);
        *count += 1;
    }

    println!("{:?}", freq);
}

medium

A. or_insert should start with 0, not 1

B. Missing mut keyword for freq

C. Cannot use entry on a vector

D. Dereferencing count is not needed

Solution

1. Step 1: Understand or_insert initial value

   or_insert(1) sets initial count to 1, but counting starts from zero.

2. Step 2: Effect of starting at 1 on counts

   Starting at 1 causes counts to be off by one; correct is or_insert(0).

3. Final Answer:

   or_insert should start with 0, not 1 -> Option A

4. Quick Check:

   Frequency count starts at zero [OK]

Hint: Start counts at 0 with or_insert(0) [OK]

Common Mistakes:

• Starting count at 1 inflates frequencies
• Forgetting mut on freq (not error here)
• Misunderstanding dereference necessity

5. Given a list of words, how would you use the Frequency Counter Pattern with a hash map in Rust to find all words that appear exactly twice? Choose the best approach.

hard

A. Count frequencies with a hash map, then collect keys with value 2 into a vector

B. Sort the list and pick every second word

C. Use a hash set to store words and print those that appear twice

D. Count frequencies but ignore words appearing more than once

Solution

1. Step 1: Use hash map to count all word frequencies

   Traverse the list, increment counts for each word in the hash map.

2. Step 2: Filter keys with frequency exactly two

   Iterate over the hash map entries and collect words with count == 2.

3. Final Answer:

   Count frequencies with a hash map, then collect keys with value 2 into a vector -> Option A

4. Quick Check:

   Frequency count + filter for 2 = correct approach [OK]

Hint: Count all, then filter keys with count 2 [OK]

Common Mistakes:

• Sorting does not guarantee frequency counts
• Hash set cannot count duplicates
• Ignoring words with frequency > 1 loses needed data