Codestin Search App

Substring Matching Pattern - Problem

Imagine you're building a search engine that needs to handle wildcard patterns. You have a text string s and a pattern p that contains exactly one * character acting as a wildcard.

The * character can be replaced with any sequence of zero or more characters (including an empty string). Your task is to determine if the pattern p can be made to match any substring of s.

Goal: Return true if pattern p can match a substring of s, false otherwise.

Example: If s = "hello world" and p = "wo*d", we can replace * with "rl" to get "world", which is a substring of s.

Input & Output

example_1.py — Basic Match

$ Input: s = "hello world", p = "wo*d"

› Output: true

💡 Note: We can replace * with "rl" to get "world", which is a substring of "hello world"

example_2.py — Empty Replacement

$ Input: s = "programming", p = "pro*ing"

› Output: true

💡 Note: We can replace * with "gramm" to get "programming", which matches the entire string

example_3.py — No Match

$ Input: s = "hello", p = "wor*ld"

› Output: false

💡 Note: Neither "wor" nor "ld" appear in "hello", so no valid substring can be formed

Constraints

1 ≤ s.length ≤ 10⁴
1 ≤ p.length ≤ 10³
s contains only lowercase English letters
p contains only lowercase English letters and exactly one '*' character
The '*' character cannot be at the start or end of p

Visualization

Tap to expand

Understanding the Visualization

Split the Pattern

Divide pattern at * into prefix and suffix parts

Search for Prefix

Find all positions where the prefix appears in the string

Check Suffix Placement

For each prefix position, see if suffix can appear later

Validate Match

Ensure there's valid spacing between prefix and suffix

Key Takeaway

🎯 Key Insight: By splitting the pattern at the wildcard, we can efficiently search for the fixed parts and validate that they can be connected with any middle section.

Asked in

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

The optimal approach splits the pattern at the '*' character into prefix and suffix parts, then uses efficient string searching to find valid matches. The key insight is that we only need to find positions where the prefix ends and the suffix can begin with any characters in between.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Positions)	O(n³)	O(1)	Try matching the pattern at every position in the string
Optimized String Search	O(n²)	O(1)	Split pattern and search efficiently using string methods

Brute Force (Check All Positions) — Algorithm Steps

Split pattern p at * into prefix and suffix
For each starting position i in string s
Check if prefix matches at position i
For each possible length of * replacement
Check if suffix matches after the replacement
Return true if any combination works

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Pattern

Divide pattern at * into prefix and suffix

Try Each Position

Check if prefix matches at each position in string

Find Suffix

For each prefix match, try all possible suffix positions

Return Result

Return true if any valid combination is found

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <cjson/cJSON.h>

bool isMatch(char* s, char* p) {
    char* starPos = strchr(p, '*');
    int starIndex = starPos - p;
    
    int n = strlen(s);
    int prefixLen = starIndex;
    int suffixLen = strlen(p) - starIndex - 1;
    
    for (int i = 0; i <= n - prefixLen; i++) {
        if (strncmp(s + i, p, prefixLen) == 0) {
            for (int j = i + prefixLen; j <= n - suffixLen; j++) {
                if (strncmp(s + j, p + starIndex + 1, suffixLen) == 0) {
                    return true;
                }
            }
        }
    }
    
    return false;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    cJSON* json = cJSON_Parse(line);
    char* s = cJSON_GetObjectItem(json, "s")->valuestring;
    char* p = cJSON_GetObjectItem(json, "p")->valuestring;
    printf("%s\n", isMatch(s, p) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each of n positions, we try all possible lengths (n) and check matches (n)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

26.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Brute Force (Check All Positions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler