Character Frequency Counting in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new empty HashMap for counting characters.

DSA Rust

let mut freq = std::collections::HashMap::[1]();

Drag options to blanks, or click blank then click option'

Aget

Bnew

Cinsert

Dremove

Attempts:

3 left

💡 Hint

Common Mistakes

Using insert or get instead of new to create the map.

Forgetting to make the map mutable.

We use HashMap::new() to create an empty map to store character counts.

2fill in blank

medium

Complete the code to get the count of a character or default to 0 if not found.

DSA Rust

let count = *freq.get(&ch).unwrap_or(&[1]);

Drag options to blanks, or click blank then click option'

A0

BNone

Cch

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using 1 as default count which is incorrect.

Using None which is not a number.

unwrap_or(&0) returns 0 if the character is not yet in the map.

3fill in blank

hard

Fix the error in updating the count for the character in the map.

DSA Rust

freq.insert(ch, count [1] 1);

Drag options to blanks, or click blank then click option'

A+

B-

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction or multiplication instead of addition.

Forgetting to update the map after increment.

We add 1 to the current count to update the frequency.

4fill in blank

hard

Fill both blanks to complete the loop that counts characters in the string.

DSA Rust

for [1] in text.chars() {
    let count = *freq.get(&[2]).unwrap_or(&0);
    freq.insert([2], count + 1);
}

Drag options to blanks, or click blank then click option'

Ach

Bc

Ctext

Dcount

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names inside and outside the loop.

Using the whole string 'text' instead of a character.

We use 'ch' as the variable for each character in the loop and to update the map.

5fill in blank

hard

Fill all three blanks to create a HashMap of character frequencies using iterator methods.

DSA Rust

let freq: std::collections::HashMap<char, usize> = text.chars()
    .fold(std::collections::HashMap::[1](), |mut acc, [2]| {
        *acc.entry([3]).or_insert(0) += 1;
        acc
    });

Drag options to blanks, or click blank then click option'

Anew

Bch

Cc

Dinsert

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong variable names inconsistent with chars().

Not using HashMap::new() to start fold.

We create a new HashMap, use 'c' as the character variable, and update counts with entry().or_insert(0).

Practice

1. What does character frequency counting mean in simple terms?

easy

A. Counting how many times each character appears in a string

B. Sorting characters alphabetically

C. Replacing characters with numbers

D. Removing duplicate characters from a string

Solution

1. Step 1: Understand the meaning of frequency counting

   Frequency counting means counting how often each item appears.

2. Step 2: Apply to characters in a string

   For characters, it means counting how many times each character shows up in the string.

3. Final Answer:

   Counting how many times each character appears in a string -> Option A

4. Quick Check:

   Frequency counting = Counting occurrences [OK]

Hint: Think: How many times does each letter show up? [OK]

Common Mistakes:

• Confusing frequency counting with sorting
• Thinking frequency means replacing characters
• Mixing frequency with removing duplicates

2. Which Rust code snippet correctly initializes an empty frequency map for characters?

easy

A. let mut freq = std::collections::HashMap::new();

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

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

D. let mut freq = 0;

Solution

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

   Frequency counting needs a map to store character keys and counts as values.

2. Step 2: Check Rust syntax for creating an empty map

   HashMap::new() creates an empty map; mut allows adding entries.

3. Final Answer:

   let mut freq = std::collections::HashMap::new(); -> Option A

4. Quick Check:

   Empty map initialization = HashMap::new() [OK]

Hint: Use HashMap::new() for empty maps in Rust [OK]

Common Mistakes:

• Using Vec or String instead of HashMap
• Not making the map mutable
• Initializing with a number instead of a map

3. What is the output of this Rust code counting characters in "hello"?

use std::collections::HashMap;
fn main() {
    let text = "hello";
    let mut freq = HashMap::new();
    for ch in text.chars() {
        *freq.entry(ch).or_insert(0) += 1;
    }
    println!("{:?}", freq);
}

medium

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

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

C. {"h": 1, "e": 1, "l": 2, "o": 1}

D. {"h": 0, "e": 0, "l": 0, "o": 0}

Solution

1. Step 1: Count each character in "hello"

   Characters: h(1), e(1), l(2), o(1).

2. Step 2: Check code logic for counting

   Code increments count for each character correctly using or_insert(0) and += 1.

3. Final Answer:

   {"h": 1, "e": 1, "l": 2, "o": 1} -> Option C

4. Quick Check:

   Count 'l' twice, others once [OK]

Hint: Count letters carefully, 'l' appears twice in 'hello' [OK]

Common Mistakes:

• Counting 'l' only once
• Confusing keys and values in map
• Assuming zero counts for characters

4. Find the error in this Rust code for counting characters:

use std::collections::HashMap;
fn main() {
    let text = "abcabc";
    let mut freq = HashMap::new();
    for ch in text.chars() {
        freq.insert(ch, freq[&ch] + 1);
    }
    println!("{:?}", freq);
}

medium

A. HashMap is not mutable

B. println! macro is missing semicolon

C. text.chars() is incorrect syntax

D. Using freq[&ch] causes panic if key not present

Solution

1. Step 1: Understand freq[&ch] usage

   freq[&ch] tries to get value for key ch but panics if key missing.

2. Step 2: Identify missing key problem

   On first occurrence, key ch is missing, so freq[&ch] causes runtime panic.

3. Final Answer:

   Using freq[&ch] causes panic if key not present -> Option D

4. Quick Check:

   Accessing missing key with [] panics [OK]

Hint: Use or_insert(0) to avoid missing key panic [OK]

Common Mistakes:

• Assuming freq[&ch] returns 0 if key missing
• Not making HashMap mutable
• Thinking text.chars() is wrong syntax

5. Given a string, how can you count only alphabetic characters ignoring digits and symbols in Rust? Choose the best approach.

hard

A. Count all characters including digits and symbols

B. Use chars().filter(|c| c.is_alphabetic()) and count frequencies

C. Convert string to bytes and count all bytes

D. Replace digits with spaces then count all characters

Solution

1. Step 1: Filter only alphabetic characters

   Use filter with is_alphabetic() to keep letters only.

2. Step 2: Count frequencies on filtered characters

   Count frequencies on filtered chars to ignore digits/symbols.

3. Final Answer:

   Use chars().filter(|c| c.is_alphabetic()) and count frequencies -> Option B

4. Quick Check:

   Filter letters first, then count [OK]

Hint: Filter letters with is_alphabetic() before counting [OK]

Common Mistakes:

• Counting digits and symbols by mistake
• Using bytes which may split characters wrongly
• Replacing digits but forgetting symbols