Codestin Search App

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".

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)?

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.

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
✓ 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)	O(m×n)	O(n)	Optimize space complexity by using only two arrays instead of full 2D table

Dynamic Programming (2D Table) — Algorithm Steps

Create a 2D DP table of size (len(s)+1) × (len(p)+1)
Initialize base cases: empty string matches empty pattern
Handle patterns ending with '*' that can match empty strings
Fill table: for each cell, check character match or wildcard rules
Return dp[len(s)][len(p)] as final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize table

Create (m+1)×(n+1) table with base cases

Handle empty string

Fill first row for patterns that can match empty string

Fill table

For each cell, apply matching rules based on current characters

Get result

Bottom-right cell contains the 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);
    // dp[i][j] = true if s[0:i] matches p[0:j]
    bool** dp = (bool**)malloc((m + 1) * sizeof(bool*));
    for (int i = 0; i <= m; i++) {
        dp[i] = (bool*)calloc(n + 1, sizeof(bool));
    }
    
    // Base case: empty string matches empty pattern
    dp[0][0] = true;
    
    // Handle patterns like a* or *a* which can match empty string
    for (int j = 1; j <= n; j++) {
        if (p[j-1] == '*') {
            dp[0][j] = dp[0][j-1];
        }
    }
    
    // Fill the DP table
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (p[j-1] == '*') {
                // '*' can match empty sequence or any sequence
                dp[i][j] = dp[i][j-1] || dp[i-1][j];
            } else if (p[j-1] == '?' || p[j-1] == s[i-1]) {
                // Character match or wildcard '?'
                dp[i][j] = dp[i-1][j-1];
            }
            // else: characters don't match, dp[i][j] remains false
        }
    }
    
    bool result = dp[m][n];
    
    // Free memory
    for (int i = 0; i <= m; i++) {
        free(dp[i]);
    }
    free(dp);
    
    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)

We fill each cell of the m×n table exactly once

✓ Linear Growth

Space Complexity

O(m×n)

We store the entire 2D DP table

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (2D Table) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler