Check If a Word Occurs As a Prefix of Any Word in a Sentence

Check If a Word Occurs As a Prefix of Any Word in a Sentence - Problem

Imagine you're building a smart autocomplete feature for a search engine! Given a sentence containing multiple words separated by spaces and a search term, you need to find if the search term appears as a prefix (beginning) of any word in the sentence.

Your task is to return the 1-indexed position of the first word that starts with the given search term. If no word starts with the search term, return -1.

Key Points:

A prefix means the search term appears at the very beginning of a word
Return the position of the first matching word (1-indexed, not 0-indexed)
If multiple words match, return the smallest index
Words are separated by single spaces

Example: In sentence "i love eating burger", searching for "burg" should return 4 because "burger" is the 4th word and starts with "burg".

Input & Output

example_1.py — Basic Match

$ Input: sentence = "i love eating burger", searchWord = "burg"

› Output: 4

💡 Note: The word "burger" is at position 4 (1-indexed) and starts with "burg", so we return 4.

example_2.py — Multiple Matches

$ Input: sentence = "this problem is an easy problem", searchWord = "pro"

› Output: 2

💡 Note: Both "problem" words start with "pro", but we return the index of the first occurrence, which is at position 2.

example_3.py — No Match

$ Input: sentence = "i am tired", searchWord = "you"

› Output: -1

💡 Note: None of the words "i", "am", or "tired" start with "you", so we return -1.

Visualization

Tap to expand

Understanding the Visualization

Walk Along Shelf

Start from the leftmost book and move right, checking each book in order

Check Each Title

For each book, look at its title and see if it starts with 'Data'

First Match

When you find the first book starting with 'Data', note its position

Return Position

Tell the person the shelf position (1st book, 2nd book, etc.)

Key Takeaway

🎯 Key Insight: Just like finding books on a shelf, we check each word in order and return the position of the first match. The built-in `startsWith()` method is like having a quick way to check book titles without reading each letter manually!

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

Where n is the number of words and m is the length of the search term. We check each word and compare up to m characters.

✓ Linear Growth

Space Complexity

O(n)

Space needed to store the array of words after splitting the sentence

⚡ Linearithmic Space

Constraints

1 ≤ sentence.length ≤ 100
1 ≤ searchWord.length ≤ 10
sentence consists of lowercase English letters and spaces
searchWord consists of lowercase English letters
Words in sentence are separated by single spaces

Asked in

a Amazon 15 ⊞ Microsoft 12 G Google 8 f Meta 6

The optimal approach uses built-in string prefix checking methods like startsWith(). Simply split the sentence into words, iterate through them, and use the built-in method to check if each word starts with the search term. Return the 1-indexed position of the first match, or -1 if no match is found. Time complexity: O(n × m) where n is the number of words and m is the search term length.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Manual Character Comparison)	O(n * m)	O(n)	Split sentence into words and manually compare each character of the search term with each word
Built-in String Methods (Optimal)	O(n * m)	O(n)	Use built-in string startsWith() or slicing methods for efficient prefix checking

Brute Force (Manual Character Comparison) — Algorithm Steps

Split the sentence into an array of words using space as delimiter
Iterate through each word with its index
For each word, manually compare characters one by one with the search term
If all characters of search term match the beginning of the word, return the 1-indexed position
If no word matches, return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Sentence

Split the sentence into individual words

Check Each Word

For each word, compare characters one by one

Character Matching

Compare each character of search term with word

Return Index

Return 1-indexed position of first matching word

Code -

solution.c — C

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

int isPrefixOfWord(char* sentence, char* searchWord) {
    char* words[1000];
    int wordCount = 0;
    
    // Split sentence into words
    char* token = strtok(sentence, " ");
    while (token != NULL && wordCount < 1000) {
        words[wordCount++] = token;
        token = strtok(NULL, " ");
    }
    
    int searchLen = strlen(searchWord);
    
    for (int i = 0; i < wordCount; i++) {
        char* word = words[i];
        int wordLen = strlen(word);
        
        // Check if searchWord is longer than current word
        if (searchLen > wordLen) {
            continue;
        }
        
        // Manual character comparison
        int isPrefix = 1;
        for (int j = 0; j < searchLen; j++) {
            if (word[j] != searchWord[j]) {
                isPrefix = 0;
                break;
            }
        }
        
        if (isPrefix) {
            return i + 1; // Return 1-indexed position
        }
    }
    
    return -1;
}

int main() {
    char sentence[10000], searchWord[1000];
    fgets(sentence, sizeof(sentence), stdin);
    fgets(searchWord, sizeof(searchWord), stdin);
    
    // Remove newlines and quotes
    sentence[strcspn(sentence, "\n")] = 0;
    searchWord[strcspn(searchWord, "\n")] = 0;
    
    if (sentence[0] == '"') {
        memmove(sentence, sentence + 1, strlen(sentence));
        sentence[strlen(sentence) - 1] = 0;
    }
    if (searchWord[0] == '"') {
        memmove(searchWord, searchWord + 1, strlen(searchWord));
        searchWord[strlen(searchWord) - 1] = 0;
    }
    
    printf("%d\n", isPrefixOfWord(sentence, searchWord));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

Where n is the number of words and m is the length of the search term. We check each word and compare up to m characters.

✓ Linear Growth

Space Complexity

O(n)

Space needed to store the array of words after splitting the sentence

⚡ Linearithmic Space

Constraints

1 ≤ sentence.length ≤ 100
1 ≤ searchWord.length ≤ 10
sentence consists of lowercase English letters and spaces
searchWord consists of lowercase English letters
Words in sentence are separated by single spaces

25.0K Views

Medium Frequency

~8 min Avg. Time

850 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 (Manual Character Comparison) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler