Replace Words

Replace Words - Problem

In English, we have a concept called root, which can be followed by some other word to form another longer word - let's call this word derivative. For example, when the root "help" is followed by the word "ful", we can form a derivative "helpful".

Given a dictionary consisting of many roots and a sentence consisting of words separated by spaces, replace all the derivatives in the sentence with the root forming it. If a derivative can be replaced by more than one root, replace it with the root that has the shortest length.

Return the sentence after the replacement.

Input & Output

Example 1 — Basic Root Replacement

$ Input: dictionary = ["cat","bat","rat"], sentence = "the cattle was rattled by the battery"

› Output: "the cat was rat by the bat"

💡 Note: "cattle" has prefix "cat", "rattled" has prefix "rat", "battery" has prefix "bat"

Example 2 — Shortest Root Priority

$ Input: dictionary = ["a","aa","aaa"], sentence = "aadsfasf absbs bbab cadsfafs"

› Output: "a a bbab cadsfafs"

💡 Note: "aadsfasf" and "absbs" both match "a" (shortest root), other words have no matching roots

Example 3 — No Matching Roots

$ Input: dictionary = ["catt","cat","bat","rat"], sentence = "the cattle was rattled by the battery"

› Output: "the cat was rat by the bat"

💡 Note: Even with "catt" in dictionary, "cat" is chosen as it's shorter and still matches "cattle"

Constraints

1 ≤ dictionary.length ≤ 1000
1 ≤ dictionary[i].length ≤ 100
1 ≤ sentence.length ≤ 10⁶
dictionary[i] and sentence consist of only lower-case letters

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Facebook 12

The key insight is to use prefix matching to find the shortest root that forms each derivative word. The optimal approach uses a Trie data structure for efficient prefix lookup, achieving O(m×k + n×k) time complexity where m is dictionary size, n is word count, and k is average string length.

Common Approaches

✓ Brute Force

⏱️ Time: O(n × m × k) Space: O(1)

For each word in the sentence, check all roots in the dictionary to see which ones are prefixes of the word. If multiple roots match, choose the shortest one.

Hash Set Optimization

⏱️ Time: O(n × k²) Space: O(m × k)

Store all roots in a hash set for fast lookup. For each word, check all possible prefixes starting from length 1 and find the shortest one that exists in the root set.

Trie-Based Solution

⏱️ Time: O(m × k + n × k) Space: O(m × k)

Construct a Trie (prefix tree) from all dictionary roots. For each word, traverse the Trie character by character to find the shortest root that matches as a prefix.

Brute Force — Algorithm Steps

Step 1: Split sentence into individual words
Step 2: For each word, check all dictionary roots
Step 3: Find shortest root that is a prefix of the word
Step 4: Replace word with root or keep original if no match

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Words

Break sentence into individual words

Check Roots

For each word, test all dictionary roots

Find Shortest

Choose the shortest matching root

Code -

solution.c — C

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

char* solution(char** dictionary, int dictSize, char* sentence) {
    char* result = malloc(1000);
    result[0] = '\0';
    
    char* token = strtok(sentence, " ");
    int first = 1;
    
    while (token != NULL) {
        char* replacement = token;
        int minLen = strlen(token) + 1;
        
        for (int i = 0; i < dictSize; i++) {
            if (strncmp(token, dictionary[i], strlen(dictionary[i])) == 0 && strlen(dictionary[i]) < minLen) {
                replacement = dictionary[i];
                minLen = strlen(dictionary[i]);
            }
        }
        
        if (!first) strcat(result, " ");
        strcat(result, replacement);
        first = 0;
        
        token = strtok(NULL, " ");
    }
    
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    line2[strcspn(line2, "\n")] = 0;
    
    // Simple parsing for dictionary array
    char* dictionary[100];
    int dictSize = 0;
    char* start = strchr(line1, '"');
    while (start) {
        start++;
        char* end = strchr(start, '"');
        if (end) {
            *end = '\0';
            dictionary[dictSize] = malloc(strlen(start) + 1);
            strcpy(dictionary[dictSize], start);
            dictSize++;
            start = strchr(end + 1, '"');
        } else break;
    }
    
    char* sentence_copy = malloc(strlen(line2) + 1);
    strcpy(sentence_copy, line2);
    
    char* result = solution(dictionary, dictSize, sentence_copy);
    printf("%s\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m × k)

n words × m roots × k average string length for prefix checking

✓ Linear Growth

Space Complexity

O(1)

Only using variables for iteration, no extra data structures

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

845 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler