Count Words with Given Prefix in DSA C++ - Deep Dive

Overview - Count Words with Given Prefix

What is it?

Counting words with a given prefix means finding how many words in a list start with certain letters. For example, if you have words like 'cat', 'car', and 'dog', and you want to count words starting with 'ca', the answer is 2. This helps in searching and organizing words quickly. It is useful in applications like autocomplete or spell checkers.

Why it matters

Without a fast way to count words by prefix, searching through large lists would be slow and inefficient. Imagine typing on your phone and waiting for a long time for suggestions. This concept makes such features fast and smooth, improving user experience and saving computing resources.

Where it fits

Before learning this, you should understand basic strings and arrays. After this, you can learn about tries (prefix trees) and advanced string searching algorithms. This topic is a stepping stone to efficient text processing.

Mental Model

Core Idea

Counting words with a given prefix is about quickly finding how many words start with certain letters without checking every word fully.

Think of it like...

It's like looking for all books on a shelf that start with the same first few letters on their spine, without pulling out every book to read the title.

Words List:
[cat, car, dog, cart, cater]
Prefix: 'ca'

Check words:
 cat  -> starts with 'ca' -> count++
 car  -> starts with 'ca' -> count++
 dog  -> no
 cart -> starts with 'ca' -> count++
 cater-> starts with 'ca' -> count++

Result: 4 words start with 'ca'

Build-Up - 6 Steps

1

Foundation

Understanding Prefixes in Words

Concept: Learn what a prefix is and how to check if a word starts with it.

A prefix is the beginning part of a word. For example, 'pre' is a prefix of 'prefix'. To check if a word starts with a prefix, compare the first letters of the word with the prefix letters one by one.

Result

You can tell if a word starts with a prefix by comparing characters from the start.

Understanding prefixes is the base for counting words that start with certain letters.

2

Foundation

Simple Counting by Checking Each Word

Concept: Count words by checking each word one by one for the prefix.

Given a list of words and a prefix, loop through each word. For each word, check if it starts with the prefix. If yes, increase the count by one.

Result

You get the total number of words starting with the prefix by scanning all words.

This method works but can be slow for large lists because it checks every word fully.

3

Intermediate

Using Sorting to Speed Up Counting

🤔Before reading on: Do you think sorting words helps find prefix matches faster or slower? Commit to your answer.

Concept: Sort words alphabetically to find prefix matches faster using binary search.

If words are sorted, all words with the same prefix appear together. Use binary search to find the first and last word with the prefix. The count is the difference between these positions.

Result

Counting becomes faster because you avoid checking every word, only searching boundaries.

Sorting groups prefix matches together, allowing quick range searches instead of full scans.

4

Intermediate

Implementing Binary Search for Prefix Range

🤔Before reading on: Will binary search find exact prefix matches or just approximate positions? Commit to your answer.

Concept: Use binary search twice: once to find the start position and once to find the end position of prefix matches.

Define a function to compare words with the prefix. Use binary search to find the smallest index where a word starts with the prefix and the largest index where words still start with it. The count is end - start + 1.

Result

You get the count of prefix matches in O(log n) time after sorting.

Binary search leverages sorted order to pinpoint prefix boundaries efficiently.

5

Advanced

Using Trie Data Structure for Fast Prefix Counting

🤔Before reading on: Do you think a trie stores whole words or parts of words? Commit to your answer.

Concept: A trie stores words by their letters in a tree structure, allowing fast prefix queries.

Build a trie where each node represents a letter. Each node keeps a count of how many words pass through it. To count words with a prefix, follow the prefix letters down the trie and read the count at the last node.

Result

Counting prefix matches becomes very fast, O(length of prefix), regardless of total words.

Tries organize words by shared prefixes, making prefix counting extremely efficient.

6

Expert

Optimizing Trie with Memory and Speed Trade-offs

🤔Before reading on: Is it better to store counts at every node or only at leaves? Commit to your answer.

Concept: Storing counts at every node speeds up prefix counting but uses more memory; storing only at leaves saves memory but slows queries.

In practice, tries store counts at each node to answer prefix queries instantly. To save memory, compressed tries or other structures like ternary search trees can be used. Balancing speed and memory depends on application needs.

Result

You understand how to tune tries for different real-world constraints.

Knowing these trade-offs helps design efficient systems that handle large word sets with prefix queries.

Under the Hood

When counting words with a prefix, the system either scans all words or uses data structures like tries or sorted arrays. Tries store words as paths of letters in a tree, with counts at nodes representing how many words share that prefix. Binary search on sorted arrays finds prefix boundaries by comparing prefixes lexicographically. These methods avoid checking every word fully, saving time.

Why designed this way?

The problem of prefix counting is common in text processing and search. Early methods scanned all words, which was slow. Sorting and binary search improved speed but still required sorting overhead. Tries were designed to store prefixes explicitly, enabling instant prefix queries. Trade-offs between memory and speed led to variations like compressed tries.

Trie Example for words: cat, car, cart

 root
  ├─ c (count=3)
  │   └─ a (count=3)
  │   │   ├─ t (count=1) [end of 'cat']
  │   │   └─ r (count=2) [end of 'car']
  │   │       └─ t (count=1) [end of 'cart']

Myth Busters - 3 Common Misconceptions

Quick: Does sorting words always make prefix counting instant? Commit yes or no.

Common Belief: Sorting words means prefix counting is always very fast.

Reality: Sorting helps but you still need binary searches to find prefix boundaries; sorting alone doesn't give instant counts.

Why it matters: Assuming sorting alone is enough can lead to inefficient code that scans many words unnecessarily.

Quick: Is a trie just a list of words stored differently? Commit yes or no.

Common Belief: A trie is just a fancy list of words with no real speed advantage.

Reality: A trie stores shared prefixes once, allowing prefix queries in time proportional to prefix length, not number of words.

Why it matters: Underestimating tries leads to missing out on huge performance gains in prefix searches.

Quick: Does storing counts only at leaf nodes in a trie give fast prefix counts? Commit yes or no.

Common Belief: Counting words with a prefix only needs counts at the ends of words (leaves).

Reality: Counts must be stored at every node to quickly know how many words share that prefix without traversing all descendants.

Why it matters: Storing counts only at leaves makes prefix counting slow, defeating the purpose of tries.

Expert Zone

1

Trie nodes can store counts of words passing through to answer prefix queries instantly, but this requires updating counts carefully during insertions and deletions.

2

Compressed tries merge chains of single-child nodes to save memory, but this complicates traversal and prefix counting logic.

3

Binary search for prefix boundaries requires careful string comparison logic to handle prefixes shorter than words and edge cases.

When NOT to use

For very small word lists, simple scanning is faster and simpler than building tries or sorting. If memory is very limited, tries may be too large; alternatives like ternary search trees or hashing might be better. For dynamic data with frequent insertions and deletions, balanced trees or hash maps with prefix hashing can be alternatives.

Production Patterns

Autocomplete systems use tries or prefix trees to suggest words instantly as users type. Search engines index prefixes using tries or sorted arrays with binary search. Spell checkers count prefix matches to suggest corrections. Real systems optimize tries with compression and memory pooling for speed and low memory use.

Connections

Trie (Prefix Tree)

Builds-on

Understanding prefix counting prepares you to learn tries, which store prefixes explicitly for fast queries.

Binary Search

Uses

Binary search on sorted words finds prefix boundaries quickly, showing how sorting and searching combine for efficiency.

Database Indexing

Similar pattern

Prefix counting is like indexing database entries by key prefixes to speed up queries, showing how data structures optimize search in many fields.

Common Pitfalls

#1 Checking every word fully even after sorting.

Wrong approach:

for (auto &word : words) {
if (word.substr(0, prefix.size()) == prefix) count++;
}

Correct approach:

int start = lower_bound(words.begin(), words.end(), prefix) - words.begin();
string next_prefix = prefix;
next_prefix.back()++;
int end = lower_bound(words.begin(), words.end(), next_prefix) - words.begin();
count = end - start;

Root cause:

Not using binary search to find prefix boundaries wastes time scanning all words.

#2 Storing counts only at leaf nodes in trie.

Wrong approach:

struct TrieNode {
bool isWord;
TrieNode* children[26];
};
// No count stored at nodes

Correct approach:

struct TrieNode {
int count;
bool isWord;
TrieNode* children[26];
};
// count updated on insertions

Root cause:

Misunderstanding that counts at internal nodes are needed for fast prefix queries.

#3 Not handling prefix longer than word length.

Wrong approach:

if (word.substr(0, prefix.size()) == prefix) count++;

Correct approach:

if (word.size() >= prefix.size() && word.substr(0, prefix.size()) == prefix) count++;

Root cause:

Ignoring edge cases where prefix is longer than some words.

Key Takeaways

Counting words with a given prefix helps find how many words start with certain letters quickly.

Simple scanning works but is slow for large lists; sorting and binary search speed up counting by finding prefix boundaries.

Tries store words by letters in a tree, allowing prefix counts in time proportional to prefix length, independent of total words.

Storing counts at every trie node is essential for fast prefix queries; this is a key design insight.

Understanding these methods prepares you for advanced text search, autocomplete, and indexing systems.

Practice

1. What does the problem "Count Words with Given Prefix" ask you to do?

easy

A. Count how many words in a list start with a specific prefix

B. Count the total number of words in a list

C. Find the longest word in a list

D. Replace the prefix in all words with another string

Solution

1. Step 1: Understand the problem statement

   The problem asks to find how many words start with a given prefix from a list of words.

2. Step 2: Identify the key operation

   We need to check each word and count those that begin with the prefix.

3. Final Answer:

   Count how many words in a list start with a specific prefix -> Option A

4. Quick Check:

   Counting words with prefix = Count how many words in a list start with a specific prefix [OK]

Hint: Focus on words starting with prefix, not total words [OK]

Common Mistakes:

• Counting all words instead of only those with prefix
• Looking for longest word instead of counting
• Replacing prefix instead of counting

2. Which of the following C++ code snippets correctly checks if a string word starts with prefix pref?

easy

A. if (word.compare(pref) == 1) { /* starts with prefix */ }

B. if (word == pref) { /* starts with prefix */ }

C. if (word.substr(1, pref.size()) == pref) { /* starts with prefix */ }

D. if (word.find(pref) == 0) { /* starts with prefix */ }

Solution

1. Step 1: Understand string::find usage

   Using word.find(pref) == 0 checks if pref is found at the start (index 0) of word.

2. Step 2: Check other options

   if (word == pref) { /* starts with prefix */ } checks equality, not prefix. if (word.substr(1, pref.size()) == pref) { /* starts with prefix */ } checks substring starting at index 1, which is wrong. if (word.compare(pref) == 1) { /* starts with prefix */ } compares strings but result 1 means greater, not prefix.

3. Final Answer:

   if (word.find(pref) == 0) { /* starts with prefix */ } -> Option D

4. Quick Check:

   find(pref) == 0 means prefix match [OK]

Hint: Use find(pref) == 0 to check prefix in C++ strings [OK]

Common Mistakes:

• Using equality instead of prefix check
• Checking substring from wrong index
• Misunderstanding compare() return values

3. What is the output of the following C++ code?

std::vector words = {"apple", "app", "application", "banana"};
std::string prefix = "app";
int count = 0;
for (const auto& w : words) {
    if (w.find(prefix) == 0) {
        count++;
    }
}
std::cout << count << std::endl;

medium

A. 3

B. 2

C. 1

D. 4

Solution

1. Step 1: Check each word for prefix "app"

   "apple" starts with "app" (count=1), "app" starts with "app" (count=2), "application" starts with "app" (count=3), "banana" does not.

2. Step 2: Count total matches

   Total words starting with "app" are 3.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   Words starting with "app" = 3 [OK]

Hint: Count words where find(prefix) == 0 inside loop [OK]

Common Mistakes:

• Counting words that contain prefix anywhere
• Off-by-one errors in counting
• Ignoring words that exactly equal prefix

4. Identify the error in this C++ code snippet that tries to count words starting with prefix pref:

int count = 0;
for (auto w : words) {
    if (w.find(pref)) {
        count++;
    }
}

medium

A. The count variable should be initialized to -1

B. The loop variable should be a reference: auto& w

C. The condition should check if w.find(pref) == 0, not just w.find(pref)

D. The find function should be replaced with substr

Solution

1. Step 1: Understand find() return value

   find() returns position or npos. Using if(w.find(pref)) treats 0 as false, so words starting at index 0 are skipped.

2. Step 2: Correct condition for prefix check

   We must check if w.find(pref) == 0 to confirm prefix at start.

3. Final Answer:

   The condition should check if w.find(pref) == 0, not just w.find(pref) -> Option C

4. Quick Check:

   Check find() == 0 for prefix [OK]

Hint: Always compare find() result to 0 for prefix check [OK]

Common Mistakes:

• Using if(w.find(pref)) which fails for prefix at start
• Not using reference in loop (less critical here)
• Initializing count incorrectly

5. Given a list of words and a prefix, how would you efficiently count words starting with the prefix if the list is very large and queried multiple times?
Choose the best approach.

hard

A. Check each word with find(prefix) == 0 every time a query comes

B. Use a Trie (prefix tree) to store words and count prefix matches quickly

C. Sort the list and use binary search to find prefix range each time

D. Store words in a hash set and check prefix membership

Solution

1. Step 1: Understand repeated prefix queries

   Checking each word every time is slow for large lists and many queries.

2. Step 2: Use Trie data structure

   A Trie stores words by prefixes, allowing fast counting of words with given prefix in O(length of prefix) time.

3. Step 3: Evaluate other options

   Binary search after sorting helps but is less efficient for many queries. Hash set doesn't support prefix queries efficiently.

4. Final Answer:

   Use a Trie (prefix tree) to store words and count prefix matches quickly -> Option B

5. Quick Check:

   Trie = fast prefix counting [OK]

Hint: Use Trie for fast repeated prefix counts [OK]

Common Mistakes:

• Checking all words each query (slow)
• Using hash set which doesn't support prefix queries
• Ignoring Trie advantages for prefix problems