Character Frequency Counting in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of character frequency count in Rust

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

DSA Rust

use std::collections::HashMap;

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

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

    let mut result: Vec<(char, i32)> = freq.into_iter().collect();
    result.sort_by_key(|&(c, _)| c);

    for (c, count) in result {
        print!("{}:{} ", c, count);
    }
}

A :1 d:1 e:1 h:1 l:3 o:2 r:1 w:1

B h:1 e:1 l:3 o:2 :1 w:1 r:1 d:1

C h:1 e:1 l:3 o:2 r:1 d:1 w:1 :1

D 1:w 1:r 2:o 3:l 1:h 1:e 1:d 1:

💡 Hint

Look carefully at how the characters are sorted before printing.

The code counts each character's frequency, including spaces. Then it sorts by character (space comes first), so output starts with space and its count, followed by characters in alphabetical order.

🧠 Conceptual

intermediate

Understanding character frequency map size

Given the string "abracadabra", how many unique characters will the frequency map contain after counting?

A 6

B 5

C 7

D 8

💡 Hint

Count distinct letters in the word.

The unique characters are a, b, r, c, d. Counting carefully, 'a', 'b', 'r', 'c', 'd' are 5 distinct letters, but 'a' appears multiple times. The unique count is 5.

🔧 Debug

advanced

Identify the error in character frequency counting code

What error will this Rust code produce when counting character frequencies? let text = "test"; let mut freq = std::collections::HashMap::new(); for ch in text.chars() { freq.insert(ch, freq[&ch] + 1); } println!("{:?}", freq);

A TypeError because freq is not mutable

B SyntaxError due to missing semicolon

C KeyError at freq[&ch] because key might not exist

D No error, prints correct frequency map

💡 Hint

Check how freq[&ch] is accessed before insertion.

Accessing freq[&ch] without ensuring the key exists causes a panic (runtime error) because the key might not be present on first insertion.

❓ Predict Output

advanced

Output of frequency counting with filtering

What is the output of this Rust code that counts only alphabetic characters in "a1b2c3a"?

DSA Rust

use std::collections::HashMap;

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

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

    let mut result: Vec<(char, i32)> = freq.into_iter().collect();
    result.sort_by_key(|&(c, _)| c);

    for (c, count) in result {
        print!("{}:{} ", c, count);
    }
}

A a:2 b:1 c:1

B a:1 b:1 c:1

C a:2 b:1 c:1 1:3

D 1:3 a:2 b:1 c:1

💡 Hint

Only alphabetic characters are counted.

Digits are skipped by the if condition, so only 'a', 'b', 'c' are counted. 'a' appears twice, 'b' and 'c' once each.

🧠 Conceptual

expert

Memory complexity of character frequency counting

What is the memory complexity of counting character frequencies in a string of length n containing only ASCII characters?

A O(n) because each character is stored separately

B O(n^2) because of nested loops in counting

C O(log n) due to sorting keys after counting

D O(1) because ASCII has fixed 128 possible characters

💡 Hint

Think about the maximum number of unique characters possible.

Since ASCII has a fixed set of 128 characters, the frequency map size is capped at 128 keys, so memory is constant regardless of string length.

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