Glob Pattern File Matcher - Problem

Advanced DP DP String Hard

Implement a file system glob pattern matcher that supports advanced wildcards:

* - matches any number of characters within a single path segment (does not cross directory separators)
** - matches across multiple directory levels (can cross directory separators)
? - matches exactly one character

Given a glob pattern and a file path, return true if the pattern matches the path, false otherwise.

Note: Directory separators are represented by forward slashes (/)

Input & Output

Example 1 — Single Segment Wildcard

$ Input: pattern = "*.txt", filepath = "file.txt"

› Output: true

💡 Note: The '*' matches 'file', then '.txt' matches exactly. Pattern successfully matches the filepath.

Example 2 — Multi-Level Wildcard

$ Input: pattern = "**/test.py", filepath = "src/utils/test.py"

› Output: true

💡 Note: The '**' matches 'src/utils' (crossing directory separator), then '/test.py' matches exactly.

Example 3 — Question Mark Wildcard

$ Input: pattern = "file?.txt", filepath = "file1.txt"

› Output: true

💡 Note: The '?' matches exactly one character '1', and the rest matches exactly.

Constraints

1 ≤ pattern.length ≤ 2000
1 ≤ filepath.length ≤ 2000
Pattern contains only lowercase letters, digits, '.', '/', '*', '?'
Filepath contains only lowercase letters, digits, '.', '/'

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6 f Meta 4

The key insight is to use dynamic programming to handle overlapping subproblems in glob pattern matching. The optimal approach uses a 2D DP table where dp[i][j] represents whether pattern[0:i] matches filepath[0:j]. Time: O(n×m), Space: O(n×m).

Common Approaches

✓ Bottom-Up 2D DP

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

Use bottom-up dynamic programming with 2D table where dp[i][j] represents whether pattern[0:i] matches filepath[0:j]. Fill table iteratively from smallest subproblems.

Memoized Dynamic Programming

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

Use top-down dynamic programming with memoization to store results of matching subproblems. Cache results based on current pattern and filepath positions.

Recursive Backtracking

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

Use recursive function to match pattern and filepath character by character, handling wildcards by trying all possibilities. No optimization for repeated subproblems.

Bottom-Up 2D DP — Algorithm Steps

Initialize DP table with base cases
Fill table row by row handling wildcards
Handle * by checking multiple previous states
Return dp[pattern_length][filepath_length]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set dp[0][0] = true, handle empty pattern cases

Fill Table

Process each cell based on current pattern character

Final Answer

dp[n][m] contains the result

Code -

solution.c — C

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

bool solution(char* pattern, char* filepath) {
    int n = strlen(pattern), m = strlen(filepath);
    // dp[i][j] = whether pattern[0:i] matches filepath[0:j]
    bool** dp = (bool**)malloc((n + 1) * sizeof(bool*));
    for (int i = 0; i <= n; i++) {
        dp[i] = (bool*)calloc(m + 1, sizeof(bool));
    }
    
    // Base case: empty pattern matches empty filepath
    dp[0][0] = true;
    
    // Handle patterns that can match empty string
    for (int i = 1; i <= n; i++) {
        if (pattern[i-1] == '*') {
            dp[i][0] = dp[i-1][0];
        } else if (i >= 2 && pattern[i-2] == '*' && pattern[i-1] == '*') {
            dp[i][0] = dp[i-2][0];
        }
    }
    
    // Fill the DP table
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            // Check for ** pattern
            if (i >= 2 && pattern[i-2] == '*' && pattern[i-1] == '*') {
                // ** can match any sequence including across directories
                dp[i][j] = dp[i-2][j] || dp[i][j-1] || dp[i-2][j-1];
            }
            // Regular * wildcard (single segment)
            else if (pattern[i-1] == '*') {
                // * matches zero or more chars in current segment
                dp[i][j] = dp[i-1][j];  // match zero
                if (filepath[j-1] != '/') {
                    dp[i][j] = dp[i][j] || dp[i][j-1];  // match one more
                }
            }
            // ? wildcard
            else if (pattern[i-1] == '?') {
                dp[i][j] = dp[i-1][j-1];
            }
            // Regular character
            else {
                dp[i][j] = dp[i-1][j-1] && pattern[i-1] == filepath[j-1];
            }
        }
    }
    
    bool result = dp[n][m];
    
    // Free memory
    for (int i = 0; i <= n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n×m)

Fill n×m DP table, each cell computed in constant time

✓ Linear Growth

Space Complexity

O(n×m)

2D DP table of size pattern_length × filepath_length

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~35 min Avg. Time

890 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

Glob Pattern File Matcher - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up 2D DP — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler