Why Count Words with Given Prefix in DSA C?

The Big Idea

What if you could find all words starting with a few letters instantly, no matter how big your list is?

The Scenario

Imagine you have a huge list of words, like a phone book or a dictionary, and you want to find how many words start with a certain set of letters, like "pre".

Doing this by checking each word one by one is like flipping through every page of a book to find all words starting with those letters.

The Problem

Checking each word manually is very slow and tiring, especially if the list is huge.

It's easy to make mistakes or miss words because you have to look at every single one.

This wastes time and effort.

The Solution

Using a special structure called a trie, we can quickly jump to the part where words with the prefix start.

This way, we don't check every word, only the relevant ones.

It's like having an index in a book that points exactly where to look.

Before vs After

✗ Before

int countWordsWithPrefix(char* words[], int size, char* prefix) {
    int count = 0;
    for (int i = 0; i < size; i++) {
        if (strncmp(words[i], prefix, strlen(prefix)) == 0) count++;
    }
    return count;
}

✓ After

typedef struct TrieNode {
    struct TrieNode* children[26];
    int prefixCount;
} TrieNode;

int countWordsWithPrefix(TrieNode* root, char* prefix) {
    TrieNode* current = root;
    for (int i = 0; prefix[i]; i++) {
        int index = prefix[i] - 'a';
        if (index < 0 || index >= 26) return 0;
        if (!current->children[index]) return 0;
        current = current->children[index];
    }
    return current->prefixCount;
}

What It Enables

This lets us find how many words start with any prefix instantly, even in huge word lists.

Real Life Example

Search engines use this to suggest words as you type, showing only words that start with what you wrote so far.

Key Takeaways

Manual checking is slow and error-prone for large word lists.

Tries store words so we can jump directly to prefixes.

Counting words with a prefix becomes fast and easy.

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 given prefix

B. Count the total number of characters in all words

C. Find the longest word in the list

D. Sort the words alphabetically

Solution

1. Step 1: Understand the problem statement

   The problem asks to find how many words start with a specific prefix string.

2. Step 2: Identify the key operation

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

3. Final Answer:

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

4. Quick Check:

   Count words starting with prefix = Count how many words in a list start with a given prefix [OK]

Hint: Look for words starting exactly with the prefix [OK]

Common Mistakes:

• Counting total characters instead of words
• Looking for words containing prefix anywhere
• Sorting words instead of counting

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

easy

A. strcmp(word, prefix) == 0

B. strncmp(word, prefix, strlen(prefix)) == 0

C. strstr(word, prefix) != NULL

D. strlen(word) == strlen(prefix)

Solution

1. Step 1: Understand string comparison functions

   strncmp compares first n characters; here n = length of prefix.

2. Step 2: Check which code confirms prefix match

   strncmp(word, prefix, strlen(prefix)) == 0 means word starts with prefix exactly.

3. Final Answer:

   strncmp(word, prefix, strlen(prefix)) == 0 -> Option B

4. Quick Check:

   strncmp with prefix length = 0 means prefix match [OK]

Hint: Use strncmp with prefix length to check start [OK]

Common Mistakes:

• Using strcmp which requires full string match
• Using strstr without checking start position
• Comparing lengths only

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

char *words[] = {"apple", "app", "application", "banana"};
char prefix[] = "app";
int count = 0;
for (int i = 0; i < 4; i++) {
  if (strncmp(words[i], prefix, strlen(prefix)) == 0) {
    count++;
  }
}
printf("%d\n", count);

medium

A. 4

B. 2

C. 1

D. 3

Solution

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

   "apple" starts with "app" (yes), "app" (yes), "application" (yes), "banana" (no).

2. Step 2: Count matching words

   Three words match the prefix, so count = 3.

3. Final Answer:

   3 -> Option D

4. Quick Check:

   Words starting with "app" = 3 [OK]

Hint: Count words where strncmp returns 0 for prefix length [OK]

Common Mistakes:

• Counting words that contain prefix anywhere
• Off-by-one errors in loop
• Incorrect prefix length in strncmp

4. Find the bug in this C code that counts words starting with prefix prefix:

int countWords(char *words[], int n, char *prefix) {
  int count = 0;
  for (int i = 0; i <= n; i++) {
    if (strncmp(words[i], prefix, strlen(prefix)) == 0) {
      count++;
    }
  }
  return count;
}

medium

A. Initialize count to 1 instead of 0

B. Use strcmp instead of strncmp

C. Loop condition should be i < n, not i <= n

D. strlen(prefix) should be replaced with strlen(words[i])

Solution

1. Step 1: Analyze loop boundary

   Loop runs from i = 0 to i <= n, which accesses words[n] (out of bounds).

2. Step 2: Correct loop condition

   Change to i < n to avoid accessing beyond array size.

3. Final Answer:

   Loop condition should be i < n, not i <= n -> Option C

4. Quick Check:

   Array index must be less than size [OK]

Hint: Use i < n for array loops to avoid overflow [OK]

Common Mistakes:

• Using <= instead of < in loops
• Confusing strcmp and strncmp usage
• Wrong length argument in strncmp

5. You have a list of words and want to count how many start with prefix pre. Which approach is best to optimize counting if you must do many prefix queries efficiently?

hard

A. Build a trie (prefix tree) from words and count nodes matching prefix

B. Use strncmp on each word for every query

C. Sort words and use binary search for prefix range

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

Solution

1. Step 1: Understand multiple prefix queries

   Checking each word with strncmp repeatedly is slow for many queries.

2. Step 2: Choose data structure for fast prefix counting

   Trie stores words by prefixes, allowing quick count of words with given prefix.

3. Step 3: Compare alternatives

   Binary search helps but trie is more direct for prefix counts; hash set doesn't support prefix queries well.

4. Final Answer:

   Build a trie (prefix tree) from words and count nodes matching prefix -> Option A

5. Quick Check:

   Trie = fast prefix count [OK]

Hint: Use trie for fast multiple prefix queries [OK]

Common Mistakes:

• Using linear search for many queries
• Ignoring trie benefits for prefix problems
• Using hash set which doesn't support prefix search