Count Prefixes of a Given String - Practice Coding Problems

Count Prefixes of a Given String - Problem

Array String Easy

Imagine you're a word validator checking which words from a dictionary could be the beginning of a target word. You're given an array of strings words and a target string s, where all characters are lowercase English letters.

Your task is to count how many strings in words are prefixes of s.

A prefix is a substring that appears at the very beginning of a string. For example:

"app" is a prefix of "apple"
"a" is a prefix of "apple"
"apple" is a prefix of itself
"ppl" is NOT a prefix of "apple" (doesn't start from beginning)

Goal: Return the count of valid prefixes found in the words array.

Input & Output

example_1.py — Basic Prefix Matching

$ Input: words = ["a", "b", "c", "ab", "bc", "abc"], s = "abc"

› Output: 3

💡 Note: The strings "a", "ab", and "abc" are prefixes of "abc". "b", "c", and "bc" are not prefixes because they don't start from the beginning.

example_2.py — No Valid Prefixes

$ Input: words = ["aa", "aaaa", "banana"], s = "aa"

› Output: 2

💡 Note: "aa" and "aaaa" need to be checked. "aa" is a valid prefix (exact match), but "aaaa" is longer than "aa" so it cannot be a prefix. "banana" doesn't start with "aa".

example_3.py — Single Character Prefixes

$ Input: words = ["a", "aa", "aaa", "aaaa"], s = "aaaa"

› Output: 4

💡 Note: All words are prefixes of "aaaa": "a" matches first char, "aa" matches first two chars, "aaa" matches first three chars, and "aaaa" is an exact match.

Visualization

Tap to expand

Understanding the Visualization

Setup Search

You have a target book title 'Advanced Algorithms' and several title fragments

Check Each Fragment

For each fragment, see if the target title starts with that exact text

Valid Matches

'A', 'Adv', 'Advanced' would all be valid - they appear at the beginning

Invalid Matches

'Algorithm', 'Book' wouldn't match - they don't start from the beginning

Key Takeaway

🎯 Key Insight: Use built-in string methods for cleaner, more efficient prefix checking rather than implementing character-by-character comparison manually.

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

Where n is number of words and m is average word length. Built-in methods are optimized but still need to check characters.

✓ Linear Growth

Space Complexity

O(1)

Only using a counter variable, no additional space needed.

✓ Linear Space

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length, s.length ≤ 1000
words[i] and s consist of lowercase English letters only
Sum of all words[i].length ≤ 10⁵

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal solution uses built-in string methods like startsWith() to efficiently check each word against the target string. This approach is clean, readable, and leverages optimized implementations with O(n×m) time complexity where n is the number of words and m is the average word length.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Character-by-Character)	O(n * m)	O(1)	Compare each word character-by-character with the beginning of target string
Built-in String Methods (Optimal)	O(n * m)	O(1)	Use built-in startsWith() or slicing methods for efficient prefix checking

Brute Force (Character-by-Character) — Algorithm Steps

Initialize a counter to 0
For each word in the words array:
- Check if word length is greater than target string length (skip if so)
- Compare each character of the word with corresponding character in target
- If all characters match, increment counter
- If any character doesn't match, move to next word
Return the final counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with count = 0, check first word

Length Check

Skip if word is longer than target string

Character Match

Compare each character position by position

Count Valid

If all characters match, increment counter

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cjson/cJSON.h>

int countPrefixesOfString(char** words, int wordsSize, char* s) {
    int count = 0;
    int sLen = strlen(s);
    
    for (int i = 0; i < wordsSize; i++) {
        int wordLen = strlen(words[i]);
        if (wordLen > sLen) {
            continue;
        }
        
        int isPrefix = 1;
        for (int j = 0; j < wordLen; j++) {
            if (words[i][j] != s[j]) {
                isPrefix = 0;
                break;
            }
        }
        
        if (isPrefix) {
            count++;
        }
    }
    
    return count;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    cJSON *json = cJSON_Parse(input);
    cJSON *words_json = cJSON_GetObjectItem(json, "words");
    cJSON *s_json = cJSON_GetObjectItem(json, "s");
    
    int wordsSize = cJSON_GetArraySize(words_json);
    char** words = malloc(wordsSize * sizeof(char*));
    
    for (int i = 0; i < wordsSize; i++) {
        cJSON *word = cJSON_GetArrayItem(words_json, i);
        words[i] = strdup(cJSON_GetStringValue(word));
    }
    
    char* s = cJSON_GetStringValue(s_json);
    
    printf("%d\n", countPrefixesOfString(words, wordsSize, s));
    
    // Cleanup
    for (int i = 0; i < wordsSize; i++) {
        free(words[i]);
    }
    free(words);
    cJSON_Delete(json);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

Where n is number of words and m is average length of words. We check each character of each word.

✓ Linear Growth

Space Complexity

O(1)

Only using a counter variable, no additional space needed.

✓ Linear Space

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length, s.length ≤ 1000
words[i] and s consist of lowercase English letters only
Sum of all words[i].length ≤ 10⁵

28.4K Views

Medium Frequency

~8 min Avg. Time

890 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

Brute Force (Character-by-Character) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler