Regular Expression Matching - Practice Coding Problems

Regular Expression Matching - Problem

You're tasked with building a powerful regular expression engine that can handle two special wildcard characters. Given an input string s and a pattern p, determine if the pattern matches the entire input string.

Your regex engine must support:

'.' - Matches any single character (like a joker card)
'*' - Matches zero or more of the preceding element

Important: The pattern must match the complete string, not just a substring. For example, pattern "a" does NOT match string "aa" because it doesn't cover the entire input.

Examples:

s = "aa", p = "a*" → true (a* means zero or more 'a's)
s = "ab", p = ".*" → true (.* matches any sequence)
s = "aab", p = "c*a*b" → true (c* matches 0 c's, a* matches 2 a's, b matches b)

Input & Output

example_1.py — Basic Star Pattern

$ Input: s = "aa", p = "a*"

› Output: true

💡 Note: The pattern 'a*' means zero or more 'a' characters. Since we have exactly 2 'a's in the string, the pattern matches perfectly.

example_2.py — Wildcard with Star

$ Input: s = "ab", p = ".*"

› Output: true

💡 Note: The pattern '.*' means zero or more of any character. This universal pattern matches any string, including 'ab'.

example_3.py — Complex Pattern

$ Input: s = "aab", p = "c*a*b"

› Output: true

💡 Note: Breaking down the pattern: 'c*' matches 0 c's (empty), 'a*' matches 2 a's, and 'b' matches the final 'b'. Together they cover the entire string 'aab'.

Visualization

Tap to expand

Understanding the Visualization

Start Investigation

Begin comparing your clues with the evidence from the beginning

Use Special Tools

When you encounter '.', it matches any single piece of evidence. When you see '*', you can use the previous clue multiple times

Make Choices

For '*' patterns, decide whether to use zero matches or keep using more matches

Memoize Results

Remember your findings at each position to avoid re-investigating the same evidence

Solve Case

Successfully match all evidence with your clues to solve the case

Key Takeaway

🎯 Key Insight: Regular expression matching is like being a detective - you need to systematically check each piece of evidence against your clues, using memoization to remember what you've already investigated. The '*' wildcard gives you choices (use zero or more), making this a perfect candidate for dynamic programming!

Time & Space Complexity

Time Complexity

⏱️

O(S × P)

Each (i,j) pair is computed at most once, and there are S×P possible pairs

✓ Linear Growth

Space Complexity

O(S × P)

Memoization table stores results for all string/pattern position combinations

✓ Linear Space

Constraints

1 ≤ s.length ≤ 20
1 ≤ p.length ≤ 30
s contains only lowercase English letters
p contains only lowercase English letters, '.', and '*'
Important: '*' will not be the first character in pattern

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses dynamic programming with memoization to achieve O(S×P) time complexity. The key insight is recognizing that this problem has overlapping subproblems - we often need to check the same string/pattern position combinations multiple times. By caching results of subproblems, we transform an exponential brute force solution into an efficient polynomial-time algorithm.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Memoized Recursion)	O(S × P)	O(S × P)	Cache recursive results to avoid redundant calculations

Dynamic Programming (Memoized Recursion) — Algorithm Steps

Create a 2D memoization table for string and pattern positions
Use the same recursive logic as brute force
Before making recursive call, check if result is already cached
Store result in cache before returning
Return cached result for future identical subproblems

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize table

Create 2D table with -1 (uncomputed) values

Compute subproblems

Fill table entries as we solve subproblems

Reuse results

Return cached results for already solved subproblems

Build solution

Combine subproblem results to get final answer

Code -

solution.c — C

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

int memo[1001][1001];
int sLen, pLen;

bool helper(char* s, char* p, int i, int j) {
    if (memo[i][j] != -1) {
        return memo[i][j];
    }
    
    bool result;
    // Base case: if pattern is exhausted
    if (j >= pLen) {
        result = i >= sLen;
    } else {
        // Check if first character matches
        bool firstMatch = i < sLen && (p[j] == s[i] || p[j] == '.');
        
        // If next character is '*'
        if (j + 1 < pLen && p[j + 1] == '*') {
            // Try zero matches or one+ matches
            result = helper(s, p, i, j + 2) || 
                    (firstMatch && helper(s, p, i + 1, j));
        } else {
            // Must match first character and continue
            result = firstMatch && helper(s, p, i + 1, j + 1);
        }
    }
    
    memo[i][j] = result ? 1 : 0;
    return result;
}

bool isMatch(char* s, char* p) {
    sLen = strlen(s);
    pLen = strlen(p);
    
    // Initialize memo table
    for (int i = 0; i <= sLen; i++) {
        for (int j = 0; j <= pLen; j++) {
            memo[i][j] = -1;
        }
    }
    
    return helper(s, p, 0, 0);
}

int main() {
    char s[1000], p[1000];
    fgets(s, sizeof(s), stdin);
    fgets(p, sizeof(p), stdin);
    
    // Remove newlines and quotes
    s[strcspn(s, "\n")] = 0;
    p[strcspn(p, "\n")] = 0;
    if (s[0] == '"') memmove(s, s+1, strlen(s));
    if (s[strlen(s)-1] == '"') s[strlen(s)-1] = 0;
    if (p[0] == '"') memmove(p, p+1, strlen(p));
    if (p[strlen(p)-1] == '"') p[strlen(p)-1] = 0;
    
    printf("%s\n", isMatch(s, p) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(S × P)

Each (i,j) pair is computed at most once, and there are S×P possible pairs

✓ Linear Growth

Space Complexity

O(S × P)

Memoization table stores results for all string/pattern position combinations

✓ Linear Space

Constraints

1 ≤ s.length ≤ 20
1 ≤ p.length ≤ 30
s contains only lowercase English letters
p contains only lowercase English letters, '.', and '*'
Important: '*' will not be the first character in pattern

89.6K Views

High Frequency

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming (Memoized Recursion) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler