Index Pairs of a String

Index Pairs of a String - Problem

Given a string text and an array of strings words, return an array of all index pairs [i, j] so that the substring text[i...j] is in words.

Return the pairs [i, j] in sorted order (i.e., sort them by their first coordinate, and in case of ties sort them by their second coordinate).

Input & Output

Example 1 — Basic Case

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

› Output: [[3,7]]

💡 Note: Only "story" appears in text starting at index 3 and ending at index 7: text[3...7] = "story"

Example 2 — Multiple Matches

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

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

💡 Note: "ab" appears at [0,1] and [2,3], "ba" appears at [1,2] and [3,4]. All pairs sorted by first coordinate, then second.

Example 3 — Overlapping Words

$ Input: text = "aaaa", words = ["aa","aaa"]

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

💡 Note: "aa" appears at [0,1], [1,2], [2,3] and "aaa" appears at [0,2], [1,3]. Results sorted naturally.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12

The key insight is to optimize word lookup by using either a hash set for O(1) checking or a Trie for efficient multi-pattern matching. The Hash Set approach converts the word list to a set and checks all substrings, achieving O(n³) time. The Trie approach builds a prefix tree and matches patterns more efficiently in O(n×L) time where L is the maximum word length.

Common Approaches

✓ Heap

⏱️ Time: N/A Space: N/A

Quickselect

⏱️ Time: N/A Space: N/A

Brute Force Substring Check

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

Generate all possible substrings of the text and check if each one exists in the words array. This involves nested loops and linear word searching.

Hash Set Optimization

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

Convert the words array to a hash set for constant-time lookups. Generate all substrings and check existence in the set rather than searching through the array.

Trie-based Pattern Matching

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

Build a Trie (prefix tree) from all words, then for each position in text, traverse the Trie to find all matching words starting from that position. This avoids generating all substrings.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int* point;
    int dist;
} HeapNode;

int compare(const void* a, const void* b) {
    HeapNode* nodeA = (HeapNode*)a;
    HeapNode* nodeB = (HeapNode*)b;
    return nodeB->dist - nodeA->dist; // Max heap
}

int** solution(int** points, int pointsSize, int* pointsColSize, int k, int* returnSize, int** returnColumnSizes) {
    HeapNode* heap = (HeapNode*)malloc(k * sizeof(HeapNode));
    int heapSize = 0;
    
    for (int i = 0; i < pointsSize; i++) {
        int dist = points[i][0]*points[i][0] + points[i][1]*points[i][1];
        
        if (heapSize < k) {
            heap[heapSize].point = points[i];
            heap[heapSize].dist = dist;
            heapSize++;
            qsort(heap, heapSize, sizeof(HeapNode), compare);
        } else if (dist < heap[0].dist) {
            heap[0].point = points[i];
            heap[0].dist = dist;
            qsort(heap, k, sizeof(HeapNode), compare);
        }
    }
    
    *returnSize = k;
    *returnColumnSizes = (int*)malloc(k * sizeof(int));
    int** result = (int**)malloc(k * sizeof(int*));
    
    for (int i = 0; i < k; i++) {
        (*returnColumnSizes)[i] = 2;
        result[i] = (int*)malloc(2 * sizeof(int));
        result[i][0] = heap[i].point[0];
        result[i][1] = heap[i].point[1];
    }
    
    free(heap);
    return result;
}

int parsePoints(char* line, int*** points) {
    int count = 0;
    *points = (int**)malloc(100 * sizeof(int*));
    
    char* ptr = line + 1; // Skip first '['
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            (*points)[count] = (int*)malloc(2 * sizeof(int));
            (*points)[count][0] = strtol(ptr, &ptr, 10);
            if (*ptr == ',') ptr++;
            (*points)[count][1] = strtol(ptr, &ptr, 10);
            count++;
        }
        ptr++;
    }
    return count;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int** points;
    int pointsSize = parsePoints(line, &points);
    
    int k;
    scanf("%d", &k);
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(points, pointsSize, NULL, k, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[%d,%d]", result[i][0], result[i][1]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    // Free memory
    for (int i = 0; i < pointsSize; i++) {
        free(points[i]);
    }
    free(points);
    for (int i = 0; i < returnSize; i++) {
        free(result[i]);
    }
    free(result);
    free(returnColumnSizes);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

456 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