Replace Words - Practice Coding Problems

Replace Words - Problem

Replace Words is a fascinating string manipulation problem that mimics how language works with roots and derivatives.

In linguistics, a root is a base word that can be extended to form longer words called derivatives. For example, the root "help" can form the derivative "helpful" when combined with the suffix "ful".

Your Task: Given a dictionary of root words and a sentence, replace all derivatives in the sentence with their shortest possible root. If multiple roots can form the same derivative, choose the shortest root.

Example: With roots ["cat", "bat", "rat"] and sentence "the cattle was rattled by the battery", return "the cat was rat by the bat".

Input & Output

example_1.py — Basic Replacement

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

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

💡 Note: "cattle" starts with "cat", "rattled" starts with "rat", and "battery" starts with "bat". Each word is replaced with its corresponding root.

example_2.py — Multiple Root Matches

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

› Output: "a a bbab cadsfafs"

💡 Note: "aadsfasf" can be replaced by "a", "aa", or "aaa", but we choose the shortest "a". "absbs" starts with "a". The other words have no matching roots.

example_3.py — No Matches

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

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

💡 Note: Even though "catt" is longer than "cat", we still choose "cat" as it's the shorter root that matches "cattle". The algorithm naturally finds the shortest matching root.

Time & Space Complexity

Time Complexity

⏱️

O(∑(len(roots)) + ∑(len(words)))

Linear time to build Trie from roots, then linear time to process each character of each word once

✓ Linear Growth

Space Complexity

O(∑(len(roots)))

Trie storage is proportional to total characters in all roots (with sharing for common prefixes)

⚡ Linearithmic Space

Constraints

1 ≤ dictionary.length ≤ 1000
1 ≤ dictionary[i].length ≤ 100
dictionary[i] consists of only lower-case letters
1 ≤ sentence.length ≤ 10⁶
sentence consists of only lower-case letters and spaces
The number of words in sentence is in the range [1, 1000]
The length of each word in sentence is in the range [1, 1000]
All dictionary words are unique

Asked in

The optimal solution uses a Trie (prefix tree) data structure to efficiently find the shortest matching root for each word. Build the Trie from dictionary roots, then traverse each word character by character until finding a root or exhausting possibilities. This achieves O(N + M) time complexity where N is total characters in the sentence and M is total characters in all roots.

Common Approaches

Approach	Time	Space	Notes
✓ Trie Data Structure (Optimal)	O(∑(len(roots)) + ∑(len(words)))	O(∑(len(roots)))	Build a Trie from roots, then traverse each word to find the shortest matching prefix
Hash Set Optimization	O(n * k²)	O(m * k)	Store roots in hash set, then check prefixes of each word efficiently
Brute Force (Check Every Root)	O(n * m * k)	O(1)	For each word, check against every root to find the shortest match

Trie Data Structure (Optimal) — Algorithm Steps

Build a Trie data structure from all dictionary roots
Mark end nodes in the Trie to identify complete roots
Split the sentence into individual words
For each word, traverse the Trie character by character
Stop at the first complete root found (shortest match) or when no path exists
Replace word with the shortest root found, or keep original if no match
Join all processed words into the result sentence

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Trie

Insert all dictionary roots into the Trie structure

Mark Roots

Mark nodes that represent complete roots in the Trie

Traverse Word

For each word, traverse the Trie character by character

Find First Root

Stop at the first complete root found (shortest match)

Code -

solution.c — C

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

#define ALPHABET_SIZE 26

typedef struct TrieNode {
    struct TrieNode* children[ALPHABET_SIZE];
    int isRoot;
} TrieNode;

TrieNode* createNode() {
    TrieNode* node = (TrieNode*)calloc(1, sizeof(TrieNode));
    node->isRoot = 0;
    return node;
}

void insertWord(TrieNode* root, const char* word) {
    TrieNode* node = root;
    for (int i = 0; word[i]; i++) {
        int index = word[i] - 'a';
        if (!node->children[index]) {
            node->children[index] = createNode();
        }
        node = node->children[index];
    }
    node->isRoot = 1;
}

char* replaceWords(char** dictionary, int dictSize, char* sentence) {
    // Build Trie from dictionary roots
    TrieNode* root = createNode();
    for (int i = 0; i < dictSize; i++) {
        insertWord(root, dictionary[i]);
    }
    
    char* result = malloc(strlen(sentence) + 1);
    char* token = strtok(sentence, " ");
    result[0] = '\0';
    
    while (token != NULL) {
        TrieNode* node = root;
        char prefix[1000] = {0};
        int found = 0;
        
        // Traverse Trie to find shortest root
        for (int i = 0; token[i] && !found; i++) {
            int index = token[i] - 'a';
            if (node->children[index]) {
                prefix[i] = token[i];
                prefix[i + 1] = '\0';
                node = node->children[index];
                if (node->isRoot) {
                    if (strlen(result) > 0) strcat(result, " ");
                    strcat(result, prefix);
                    found = 1;
                }
            } else {
                break;
            }
        }
        
        // Keep original word if no root found
        if (!found) {
            if (strlen(result) > 0) strcat(result, " ");
            strcat(result, token);
        }
        
        token = strtok(NULL, " ");
    }
    
    return result;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(∑(len(roots)) + ∑(len(words)))

Linear time to build Trie from roots, then linear time to process each character of each word once

✓ Linear Growth

Space Complexity

O(∑(len(roots)))

Trie storage is proportional to total characters in all roots (with sharing for common prefixes)

⚡ Linearithmic Space

Constraints

1 ≤ dictionary.length ≤ 1000
1 ≤ dictionary[i].length ≤ 100
dictionary[i] consists of only lower-case letters
1 ≤ sentence.length ≤ 10⁶
sentence consists of only lower-case letters and spaces
The number of words in sentence is in the range [1, 1000]
The length of each word in sentence is in the range [1, 1000]
All dictionary words are unique

25.0K Views

Medium Frequency

~15 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Trie Data Structure (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler