Check If String Is a Prefix of Array - Practice Coding Problems

Check If String Is a Prefix of Array - Problem

Given a string s and an array of strings words, determine whether s is a prefix string of words.

A string s is a prefix string of words if s can be made by concatenating the first k strings in words for some positive integer k (where k ≤ words.length).

For example, if words = ["hello", "world", "leetcode"], then:

"hello" is a prefix string (k=1)
"helloworld" is a prefix string (k=2)
"helloworldleetcode" is a prefix string (k=3)
"hellow" is NOT a prefix string (partial words not allowed)

Goal: Return true if s is a prefix string of words, or false otherwise.

Input & Output

example_1.py — Basic Match

$ Input: s = "iloveleetcode", words = ["i", "love", "leetcode", "apples"]

› Output: true

💡 Note: We can form "iloveleetcode" by concatenating the first 3 words: "i" + "love" + "leetcode" = "iloveleetcode"

example_2.py — No Match

$ Input: s = "iloveleetcode", words = ["apples", "i", "love", "leetcode"]

› Output: false

💡 Note: We cannot form "iloveleetcode" starting from "apples". We can only use words from the beginning of the array in order.

example_3.py — Partial Word Not Allowed

$ Input: s = "ilove", words = ["i", "love", "leetcode"]

› Output: true

💡 Note: We can form "ilove" by concatenating the first 2 words: "i" + "love" = "ilove". We don't need to use all words.

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with an index at position 0 of the target string

Check Each Word

For each word, verify it matches the expected portion of target string

Advance or Stop

If word matches, advance index; if not, return false

Check Completion

If index equals target length exactly, we found a valid prefix

Key Takeaway

🎯 Key Insight: We can solve this efficiently in O(n) time by building incrementally and checking for exact matches, avoiding the need to rebuild strings multiple times.

Time & Space Complexity

Time Complexity

⏱️

O(n)

n is the total number of characters in s. We examine each character at most once.

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track indices, no extra space for string building

✓ Linear Space

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 20
1 ≤ s.length ≤ 1000
words[i] and s consist of only lowercase English letters

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 Apple 8

The optimal solution uses a single-pass approach with O(n) time complexity. Instead of rebuilding concatenated strings for each possible k, we incrementally match each word against the corresponding portion of the target string. This approach provides early termination on mismatches and uses O(1) extra space.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Incremental Build (Optimal)	O(n)	O(1)	Build the concatenated string incrementally while comparing character by character
Brute Force (Multiple String Builds)	O(n × m)	O(m)	Try every possible prefix length by rebuilding strings from scratch

Single Pass Incremental Build (Optimal) — Algorithm Steps

Initialize an index to track position in target string s
Iterate through each word in the words array
For each word, check if it matches the corresponding part of s
If word doesn't match, return false immediately
If we've matched entire s exactly, return true
If we exceed s length, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Initialize index = 0, start with first word

Match word

Check if current word matches s[index:index+len(word)]

Advance

Move index forward by word length

Check completion

If index equals s length, we found a match

Code -

solution.c — C

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

int isPrefixString(char* s, char** words, int wordsSize) {
    int index = 0;
    int sLen = strlen(s);
    
    for (int i = 0; i < wordsSize; i++) {
        int wordLen = strlen(words[i]);
        
        // Check if current word matches the corresponding part of s
        if (index + wordLen > sLen) {
            return 0;
        }
        
        if (strncmp(s + index, words[i], wordLen) != 0) {
            return 0;
        }
        
        index += wordLen;
        
        // If we've matched entire s, return true
        if (index == sLen) {
            return 1;
        }
    }
    
    return 0;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

n is the total number of characters in s. We examine each character at most once.

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track indices, no extra space for string building

✓ Linear Space

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 20
1 ≤ s.length ≤ 1000
words[i] and s consist of only lowercase English letters

28.4K Views

Medium Frequency

~12 min Avg. Time

892 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

Single Pass Incremental Build (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler