Pattern Matching Automaton - Problem

Advanced DP DP Automata Hard

Build a deterministic finite automaton (DFA) from a given pattern and simulate it to find all matches in a text string. A DFA is a state machine that processes characters one by one and determines if the current prefix matches the pattern or leads to a potential match.

Given a pattern string pattern and a text string text, return an array of all starting indices where the pattern appears in the text.

The automaton should use the failure function (similar to KMP algorithm) to efficiently handle mismatches by jumping to the appropriate state rather than restarting from the beginning.

Example: If pattern = "aba" and text = "abababa", the pattern appears at indices [0, 2, 4], so return [0, 2, 4].

Input & Output

Example 1 — Basic Pattern Matching

$ Input: pattern = "aba", text = "abababa"

› Output: [0,2,4]

💡 Note: Pattern 'aba' appears at indices 0 ('aba'babba), 2 (ab'aba'ba), and 4 (abab'aba')

Example 2 — No Matches

$ Input: pattern = "abc", text = "def"

› Output: []

💡 Note: Pattern 'abc' does not appear anywhere in text 'def'

Example 3 — Single Character Pattern

$ Input: pattern = "a", text = "aaa"

› Output: [0,1,2]

💡 Note: Single character 'a' appears at every position: indices 0, 1, and 2

Constraints

1 ≤ pattern.length ≤ 1000
1 ≤ text.length ≤ 10⁴
pattern and text consist of lowercase English letters only

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is using a failure function to avoid redundant comparisons after mismatches. The optimal KMP algorithm builds a partial match table and scans text in linear time. Time: O(n + m), Space: O(m)

Common Approaches

✓ Brute Force Pattern Matching

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

For each position in the text, try to match the entire pattern character by character. When a mismatch occurs, move to the next starting position and restart the matching process completely.

KMP Algorithm with Failure Function

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

Build a failure function (partial match table) that tells us how much of the pattern we can reuse when a mismatch occurs. This eliminates the need to restart pattern matching from scratch.

Brute Force Pattern Matching — Algorithm Steps

Iterate through each position in text
For each position, compare pattern characters one by one
If mismatch occurs, move to next starting position
Continue until all positions are checked

Visualization

Tap to expand

Step-by-Step Walkthrough

Position 0

Match A-B-A successfully, found match at index 0

Position 1

Try B-A-B, fails at first character, move to next

Continue

Check each remaining position independently

Code -

solution.c — C

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

int* solution(char* pattern, char* text, int* returnSize) {
    int n = strlen(text), m = strlen(pattern);
    int* matches = malloc(n * sizeof(int));
    *returnSize = 0;
    
    for (int i = 0; i <= n - m; i++) {
        int match = 1;
        for (int j = 0; j < m; j++) {
            if (text[i + j] != pattern[j]) {
                match = 0;
                break;
            }
        }
        if (match) {
            matches[(*returnSize)++] = i;
        }
    }
    
    return matches;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n×m)

For each of n positions in text, we might compare up to m pattern characters

✓ Linear Growth

Space Complexity

O(1)

Only uses constant extra space for indices and variables

✓ Linear Space

23.4K Views

Medium Frequency

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

Pattern Matching Automaton - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Pattern Matching — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler