Regex Pattern Matcher - Problem

Build a simple regex engine that supports . (matches any character), * (matches zero or more of the preceding character), and ? (matches zero or one of the preceding character) wildcards for pattern matching.

Pattern Rules:

. matches any single character
* matches zero or more occurrences of the character immediately before it
? matches zero or one occurrence of the character immediately before it
Regular characters match themselves exactly

Return true if the entire string matches the pattern, false otherwise.

Input & Output

Example 1 — Basic Wildcard Matching

$ Input: text = "ab", pattern = "a*b"

› Output: true

💡 Note: Pattern 'a*' matches 'a' (one occurrence of 'a'), then 'b' matches 'b' exactly

Example 2 — Dot Wildcard

$ Input: text = "ac", pattern = "a."

› Output: true

💡 Note: '.' matches any character, so 'a.' matches 'ac' where '.' matches 'c'

Example 3 — Question Mark Optional

$ Input: text = "ab", pattern = "ab?"

› Output: true

💡 Note: 'b?' means 'b' is optional, but 'b' is present, so pattern matches

Constraints

1 ≤ text.length ≤ 1000
1 ≤ pattern.length ≤ 1000
text contains only lowercase English letters
pattern contains lowercase English letters, '.', '*', and '?'

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 f Facebook 22 M Microsoft 18

The key insight is to use dynamic programming to avoid recomputing overlapping subproblems. The optimal approach builds a 2D table where each cell represents whether a substring of text matches a subpattern. Time: O(m×n), Space: O(m×n)

Common Approaches

✓ Dynamic Programming

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

Create a 2D DP table where dp[i][j] represents whether text[0...i-1] matches pattern[0...j-1]. Fill the table systematically from base cases to the final answer.

Memoized Recursion

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

Same recursive logic but store results of subproblems in a cache to avoid redundant calculations when the same text/pattern positions are encountered again.

Recursive Backtracking

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

Use recursion to explore every possible way the pattern could match the text. When encountering wildcards, try all possibilities and backtrack if they don't work.

Dynamic Programming — Algorithm Steps

Initialize DP table with base cases
Handle empty pattern and text cases
Fill table using recurrence relations for wildcards
Return dp[text_length][pattern_length]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Table

Create DP table with base cases

Fill Table

Use recurrence relations to fill each cell

Read Answer

Bottom-right cell contains final result

Code -

solution.c — C

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

bool solution(const char* text, const char* pattern) {
    int m = strlen(text), n = strlen(pattern);
    bool** dp = malloc((m + 1) * sizeof(bool*));
    for (int i = 0; i <= m; i++) {
        dp[i] = calloc(n + 1, sizeof(bool));
    }
    
    dp[0][0] = true;
    
    for (int j = 2; j <= n; j += 2) {
        if (pattern[j - 1] == '*') {
            dp[0][j] = dp[0][j - 2];
        }
    }
    
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (pattern[j - 1] == '*') {
                dp[i][j] = dp[i][j - 2] || (dp[i - 1][j] && (pattern[j - 2] == '.' || pattern[j - 2] == text[i - 1]));
            } else if (pattern[j - 1] == '?') {
                dp[i][j] = dp[i][j - 1] || (j > 1 && dp[i - 1][j - 1] && (pattern[j - 2] == '.' || pattern[j - 2] == text[i - 1]));
            } else if (pattern[j - 1] == '.' || pattern[j - 1] == text[i - 1]) {
                dp[i][j] = dp[i - 1][j - 1];
            }
        }
    }
    
    bool result = dp[m][n];
    
    for (int i = 0; i <= m; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    char text[1001], pattern[1001];
    fgets(text, sizeof(text), stdin);
    fgets(pattern, sizeof(pattern), stdin);
    text[strcspn(text, "\n")] = 0;
    pattern[strcspn(pattern, "\n")] = 0;
    bool result = solution(text, pattern);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Fill m×n DP table, each cell takes constant time

✓ Linear Growth

Space Complexity

O(m×n)

DP table stores result for each text/pattern position combination

⚡ Linearithmic Space

98.5K Views

Medium Frequency

~35 min Avg. Time

2.8K 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

Regex Pattern Matcher - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler