Index Pairs of a String - Practice Coding Problems

Index Pairs of a String - Problem

Index Pairs of a String

You're a text editor developer building a word highlighting feature. Given a document text and a dictionary of words to highlight, you need to find all occurrences of these words in the text and return their positions.

Task: Return an array of index pairs [i, j] where each pair represents the start and end positions of a word from the dictionary found in the text. The substring text[i...j] (inclusive) must exactly match one of the words.

Important: Results must be sorted by start position first, then by end position if there are ties. This ensures consistent highlighting order in your text editor.

Example: If text = "thestoryofleetcodeandme" and words = ["story", "fleet", "leetcode"], you should find "story" at positions [3,7], "leetcode" at [8,15], creating pairs [[3,7], [8,15]].

Input & Output

example_1.py — Basic Case

$ Input: text = "thestoryofleetcodeandme", words = ["story","fleet","leetcode"]

› Output: [[3,7],[9,12],[10,17]]

💡 Note: Found "story" at positions 3-7, "fleet" at 9-12, and "leetcode" at 10-17. Note that "fleet" and "leetcode" overlap, which is allowed.

example_2.py — Single Character

$ Input: text = "ababa", words = ["aba","ab"]

› Output: [[0,1],[0,2],[2,3],[2,4]]

💡 Note: Found "ab" at [0,1] and [2,3], "aba" at [0,2] and [2,4]. Multiple overlapping matches are included.

example_3.py — No Matches

$ Input: text = "wordgoodsword", words = ["word","good","best"]

› Output: [[0,3],[4,7],[8,11]]

💡 Note: Found "word" at [0,3] and [8,11], "good" at [4,7]. "best" is not found in the text.

Visualization

Tap to expand

Understanding the Visualization

Build Search Index

Create a Trie (prefix tree) from all keywords you want to highlight

Scan Document

Move through the text character by character, starting fresh searches at each position

Follow Paths

At each position, follow the Trie paths as far as possible, collecting complete word matches

Mark Highlights

Record the start and end positions of each found keyword for the highlighting system

Key Takeaway

🎯 Key Insight: The Trie data structure enables us to search for multiple patterns simultaneously in a single pass, making it the optimal solution for multi-pattern string matching problems.

Time & Space Complexity

Time Complexity

⏱️

O(n × L + m × L)

O(n × L) to scan text × max word length + O(m × L) to build Trie

✓ Linear Growth

Space Complexity

O(m × L + k)

O(m × L) for Trie nodes + O(k) for result pairs

✓ Linear Space

Constraints

1 ≤ words.length ≤ 20
1 ≤ words[i].length ≤ text.length ≤ 100
text and words[i] consist of lowercase English letters only
All the strings of words are unique

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 29 f Meta 24

The optimal solution uses a Trie (prefix tree) data structure for efficient multi-pattern matching. Build the Trie from all words, then scan the text once, traversing the Trie at each position to find all matching patterns. This achieves O(n × L + m × L) time complexity and naturally produces sorted results.

Common Approaches

Approach	Time	Space	Notes
✓ Trie-Based Pattern Matching (Optimal)	O(n × L + m × L)	O(m × L + k)	Use Trie data structure for efficient multi-pattern matching
Brute Force (Check All Substrings)	O(n³ + m)	O(k)	Check every possible substring against the word list
Hash Set + Substring Generation	O(n² × L + m)	O(m × L + k)	Build hash set of words first, then efficiently check all substrings

Trie-Based Pattern Matching (Optimal) — Algorithm Steps

Build a Trie data structure from all words
Mark end-of-word nodes in the Trie
For each starting position i in text, traverse the Trie
As we match characters, collect any complete words found
Add [i, j] pairs for each complete word ending at position j
Results are naturally sorted since we scan left to right

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Trie

Create prefix tree from all words

Scan Text

For each position, traverse Trie as far as possible

Collect Matches

Record all complete words found during traversal

Natural Order

Results are already sorted by scanning left-to-right

Code -

solution.c — C

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

#define ALPHABET_SIZE 256

typedef struct TrieNode {
    struct TrieNode* children[ALPHABET_SIZE];
    bool isWord;
} TrieNode;

TrieNode* createNode() {
    TrieNode* node = (TrieNode*)malloc(sizeof(TrieNode));
    for (int i = 0; i < ALPHABET_SIZE; i++) {
        node->children[i] = NULL;
    }
    node->isWord = false;
    return node;
}

void insertWord(TrieNode* root, char* word) {
    TrieNode* node = root;
    for (int i = 0; word[i] != '\0'; i++) {
        int index = (unsigned char)word[i];
        if (node->children[index] == NULL) {
            node->children[index] = createNode();
        }
        node = node->children[index];
    }
    node->isWord = true;
}

int** indexPairs(char* text, char** words, int wordsSize, int* returnSize, int** returnColumnSizes) {
    // Build Trie
    TrieNode* root = createNode();
    for (int i = 0; i < wordsSize; i++) {
        insertWord(root, words[i]);
    }
    
    int textLen = strlen(text);
    int** result = (int**)malloc(textLen * textLen * sizeof(int*));
    *returnColumnSizes = (int*)malloc(textLen * textLen * sizeof(int));
    int count = 0;
    
    // Search for patterns starting at each position
    for (int i = 0; i < textLen; i++) {
        TrieNode* node = root;
        for (int j = i; j < textLen; j++) {
            int index = (unsigned char)text[j];
            if (node->children[index] == NULL) {
                break;
            }
            node = node->children[index];
            if (node->isWord) {
                result[count] = (int*)malloc(2 * sizeof(int));
                result[count][0] = i;
                result[count][1] = j;
                (*returnColumnSizes)[count] = 2;
                count++;
            }
        }
    }
    
    *returnSize = count;
    return result;  // Already sorted by construction
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n × L + m × L)

O(n × L) to scan text × max word length + O(m × L) to build Trie

✓ Linear Growth

Space Complexity

O(m × L + k)

O(m × L) for Trie nodes + O(k) for result pairs

✓ Linear Space

Constraints

1 ≤ words.length ≤ 20
1 ≤ words[i].length ≤ text.length ≤ 100
text and words[i] consist of lowercase English letters only
All the strings of words are unique

28.4K Views

Medium Frequency

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

Trie-Based Pattern Matching (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler