Counting Words With a Given Prefix - Practice Coding Problems

Counting Words With a Given Prefix - Problem

Imagine you're building a search autocomplete feature! You have an array of strings words and a search prefix pref.

Your task is to count how many words in the array start with the given prefix. A prefix is simply the beginning part of a string - any leading contiguous substring.

Goal: Return the number of strings in words that have pref as a prefix.

Example: If words = ["apple", "app", "apricot", "banana"] and pref = "ap", then 3 words start with "ap": "apple", "app", and "apricot".

Input & Output

example_1.py — Basic prefix matching

$ Input: words = ["pay","attention","practice","attend"], pref = "at"

› Output: 2

💡 Note: The words that start with "at" are "attention" and "attend", so we return 2.

example_2.py — No matches found

$ Input: words = ["leetcode","win","loops","success"], pref = "code"

› Output: 0

💡 Note: None of the words start with "code" as a prefix, so we return 0.

example_3.py — All words match

$ Input: words = ["apple","app","application"], pref = "app"

› Output: 3

💡 Note: All three words start with "app": "apple", "app", and "application".

Visualization

Tap to expand

Understanding the Visualization

User types prefix

Search box receives 'ap' as input

Scan word database

System checks each word in the database

Match prefixes

Count words that start with 'ap'

Return count

Display number of matching results

Key Takeaway

🎯 Key Insight: Modern string prefix checking is essentially what powers autocomplete systems - count matches efficiently using built-in methods!

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

Where n is number of words and m is length of prefix (built-in methods are optimized)

✓ Linear Growth

Space Complexity

O(1)

Only using a counter variable, no extra space needed

✓ Linear Space

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length, pref.length ≤ 1000
words[i] and pref consist of lowercase English letters only
Edge case: Empty prefix matches all words

Asked in

G Google 45 ⊞ Microsoft 38 a Amazon 32 f Meta 28

The optimal approach uses built-in string methods like startsWith() to efficiently check each word against the prefix. This results in clean, readable code with O(n*m) time complexity where n is the number of words and m is the prefix length. The key insight is leveraging optimized built-in functions rather than manual character comparison.

Common Approaches

Approach	Time	Space	Notes
✓ Built-in String Methods (Optimal)	O(n * m)	O(1)	Use language built-in startsWith() or substring methods for efficient prefix checking
Manual Character Comparison	O(n * m)	O(1)	Compare each word character by character with the prefix

Built-in String Methods (Optimal) — Algorithm Steps

Initialize a counter to 0
For each word in the words array
Use built-in startsWith() method or substring comparison
If the word starts with the prefix, increment counter
Return the final counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Use startsWith()

Built-in method handles character comparison efficiently

Iterate once

Single pass through all words in the array

Count matches

Increment counter for each word that starts with prefix

Return result

Final count of matching words

Code -

solution.c — C

#include <stdio.h>
#include <string.h>

int prefixCount(char words[][100], int wordsSize, char* pref) {
    int count = 0;
    int prefLen = strlen(pref);
    
    for (int i = 0; i < wordsSize; i++) {
        if (strncmp(words[i], pref, prefLen) == 0) {
            count++;
        }
    }
    return count;
}

int main() {
    char words[][100] = {"apple", "app", "apricot", "banana"};
    char pref[] = "ap";
    printf("%d\n", prefixCount(words, 4, pref));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

Where n is number of words and m is length of prefix (built-in methods are optimized)

✓ Linear Growth

Space Complexity

O(1)

Only using a counter variable, no extra space needed

✓ Linear Space

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length, pref.length ≤ 1000
words[i] and pref consist of lowercase English letters only
Edge case: Empty prefix matches all words

28.8K Views

Medium Frequency

~8 min Avg. Time

1.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Built-in String Methods (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler