Wildcard Matching - Practice Coding Problems

Wildcard Matching - Problem

You're building a file search system that needs to match filenames against patterns with wildcards! 🔍

Given an input string s and a pattern p, implement wildcard pattern matching with support for:

'?' - Matches exactly one character (like a single letter placeholder)
'*' - Matches any sequence of characters, including empty sequence (the ultimate wildcard!)

The matching must cover the entire input string - no partial matches allowed. Think of it like checking if a filename exactly matches a search pattern.

Examples:

s = "adceb", p = "*a*b" → true (pattern matches any chars + 'a' + any chars + 'b')
s = "adceb", p = "a?c?b" → true ('a' + any char + 'c' + any char + 'b')
s = "cb", p = "?a" → false (second char must be 'a', but it's 'b')

Input & Output

example_1.py — Basic Wildcard Matching

$ Input: s = "adceb", p = "*a*b"

› Output: true

💡 Note: The first '*' matches the empty sequence, while the second '*' matches "dce". The pattern becomes "" + "a" + "dce" + "b" = "adceb", which matches the input string.

example_2.py — Question Mark Wildcard

$ Input: s = "adceb", p = "a?c?b"

› Output: true

💡 Note: The first '?' matches 'd', and the second '?' matches 'e'. The pattern becomes "a" + "d" + "c" + "e" + "b" = "adceb", which exactly matches the input string.

example_3.py — No Match Case

$ Input: s = "cb", p = "?a"

› Output: false

💡 Note: The '?' can match 'c', but then we need 'a' to match 'b', which is impossible. There's no way to make the pattern "?a" match the string "cb".

Visualization

Tap to expand

Understanding the Visualization

Initialize base cases

Empty string matches empty pattern, handle leading '*' wildcards

Character by character

For each position, determine if current characters can match

Handle wildcards

'?' matches any single char, '*' matches zero or more chars

Build solution

Combine partial matches to determine if entire string matches pattern

Key Takeaway

🎯 Key Insight: Dynamic Programming efficiently handles the exponential possibilities of '*' wildcards by storing intermediate results, avoiding repeated computations.

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Still need to process every character combination once

✓ Linear Growth

Space Complexity

O(n)

Only store two arrays of size n (pattern length)

⚡ Linearithmic Space

Constraints

0 ≤ s.length, p.length ≤ 2000
s contains only lowercase English letters
p contains only lowercase English letters, '?' or '*'
Follow up: Could you improve the space complexity to O(n)?

Asked in

G Google 25 a Amazon 20 ⊞ Microsoft 15 f Facebook 12

The optimal solution uses dynamic programming with space optimization. We build a DP table where each cell represents whether a substring matches a sub-pattern. The key insight is that '*' can match zero or more characters, so we consider both possibilities. Space can be optimized from O(mn) to O(n) by using only two arrays instead of a full 2D table.

Common Approaches

Approach	Time	Space	Notes
✓ Space-Optimized DP (Optimal)	O(m×n)	O(n)	Optimize space complexity by using only two arrays instead of full 2D table
Dynamic Programming (2D Table)	O(m×n)	O(m×n)	Build a 2D DP table to store matching results for all subproblems

Space-Optimized DP (Optimal) — Algorithm Steps

Use two 1D arrays: prev (previous row) and curr (current row)
Initialize prev array with base cases for empty string
For each character in string, compute curr array from prev array
Swap prev and curr arrays for next iteration
Return the last element of prev array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize arrays

Create prev and curr arrays, initialize base cases

Process each row

For each character in string, compute curr from prev

Swap arrays

Move curr to prev for next iteration

Return result

Last element of prev contains final answer

Code -

solution.c — C

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

bool isMatch(char* s, char* p) {
    int m = strlen(s), n = strlen(p);
    
    // Use two 1D arrays instead of 2D table
    bool* prev = (bool*)calloc(n + 1, sizeof(bool));
    bool* curr = (bool*)calloc(n + 1, sizeof(bool));
    
    // Base case: empty string matches empty pattern
    prev[0] = true;
    
    // Handle patterns like a* or *a* which can match empty string
    for (int j = 1; j <= n; j++) {
        if (p[j-1] == '*') {
            prev[j] = prev[j-1];
        }
    }
    
    // Fill the DP table row by row
    for (int i = 1; i <= m; i++) {
        curr[0] = false; // Non-empty string can't match empty pattern
        
        for (int j = 1; j <= n; j++) {
            if (p[j-1] == '*') {
                // '*' can match empty sequence or any sequence
                curr[j] = curr[j-1] || prev[j];
            } else if (p[j-1] == '?' || p[j-1] == s[i-1]) {
                // Character match or wildcard '?'
                curr[j] = prev[j-1];
            } else {
                // Characters don't match
                curr[j] = false;
            }
        }
        
        // Swap arrays for next iteration
        bool* temp = prev;
        prev = curr;
        curr = temp;
    }
    
    bool result = prev[n];
    free(prev);
    free(curr);
    return result;
}

int main() {
    char s[1001], p[1001];
    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));
        s[strlen(s)-1] = 0;
    }
    if (p[0] == '"') {
        memmove(p, p+1, strlen(p));
        p[strlen(p)-1] = 0;
    }
    
    printf("%s\n", isMatch(s, p) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Still need to process every character combination once

✓ Linear Growth

Space Complexity

O(n)

Only store two arrays of size n (pattern length)

⚡ Linearithmic Space

Constraints

0 ≤ s.length, p.length ≤ 2000
s contains only lowercase English letters
p contains only lowercase English letters, '?' or '*'
Follow up: Could you improve the space complexity to O(n)?

116.6K Views

Medium-High Frequency

~25 min Avg. Time

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

Space-Optimized DP (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler