KMP String Matching - Problem

The KMP (Knuth-Morris-Pratt) algorithm is an efficient string matching algorithm that finds all occurrences of a pattern within a text string in linear time.

Your task is to implement the complete KMP algorithm:

Build the failure function (also called prefix function or LPS array)
Use the failure function to perform pattern matching
Return a list of all starting indices where the pattern occurs in the text

The failure function lps[i] stores the length of the longest proper prefix of pattern[0...i] that is also a suffix of pattern[0...i].

Example: For pattern "ABABCABAB", the failure function is [0,0,1,2,0,1,2,3,4]

Input & Output

Example 1 — Basic Pattern Matching

$ Input: text = "ABABCABAB", pattern = "ABAB"

› Output: [0,5]

💡 Note: Pattern 'ABAB' appears at index 0 (ABAB-CABAB) and index 5 (ABABC-ABAB). The KMP algorithm finds both occurrences efficiently using the failure function.

Example 2 — No Matches

$ Input: text = "HELLO", pattern = "WORLD"

› Output: []

💡 Note: Pattern 'WORLD' does not appear anywhere in text 'HELLO', so return empty array.

Example 3 — Overlapping Patterns

$ Input: text = "AAAA", pattern = "AA"

› Output: [0,1,2]

💡 Note: Pattern 'AA' appears at positions 0 (AA-AA), 1 (A-AA-A), and 2 (AA-AA). KMP handles overlapping matches correctly.

Constraints

1 ≤ text.length ≤ 10⁴
1 ≤ pattern.length ≤ 10³
text and pattern contain only uppercase English letters

Visualization

Tap to expand

Asked in

G Google 85 M Microsoft 72 a Amazon 65 f Facebook 58

The key insight is preprocessing the pattern to build a failure function that indicates how much to skip on mismatches. The KMP algorithm achieves optimal linear time complexity by never re-examining characters in the text. Time: O(n + m), Space: O(m)

Common Approaches

✓ Brute Force

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

For each position in the text, try to match the entire pattern character by character. If a mismatch occurs, move to the next position and start pattern matching from the beginning again.

KMP Algorithm

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

The KMP algorithm preprocesses the pattern to build a failure function (LPS array) that indicates how much to skip when a mismatch occurs, avoiding re-examination of previously matched characters.

Brute Force — Algorithm Steps

Start at each position i in text
Try to match pattern[0...m-1] with text[i...i+m-1]
On mismatch, move to position i+1 and restart
Record index i if complete match found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Try to match entire pattern from beginning

On mismatch, move right

Shift one position and restart pattern matching

Repeat until end

Continue checking every possible position

Code -

solution.c — C

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

void solution(char* text, char* pattern, int* result, int* count) {
    int n = strlen(text), m = strlen(pattern);
    *count = 0;
    
    for (int i = 0; i <= n - m; i++) {
        int j = 0;
        while (j < m && text[i + j] == pattern[j]) {
            j++;
        }
        if (j == m) {
            result[(*count)++] = i;
        }
    }
}

int main() {
    char text[10001], pattern[1001];
    fgets(text, sizeof(text), stdin);
    fgets(pattern, sizeof(pattern), stdin);
    
    text[strcspn(text, "\n")] = 0;
    pattern[strcspn(pattern, "\n")] = 0;
    
    int result[10000], count;
    solution(text, pattern, result, &count);
    
    printf("[");
    for (int i = 0; i < count; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m)

For each of n positions, we may check up to m characters

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for indices

✓ Linear Space

28.5K Views

Medium Frequency

~35 min Avg. Time

890 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

KMP String Matching - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler