Shortest Matching Substring - Practice Coding Problems

Shortest Matching Substring - Problem

Pattern Matching with Wildcards

You're given a string s and a pattern p that contains exactly two '*' characters. Each '*' acts as a wildcard that can match any sequence of zero or more characters.

Your task is to find the shortest substring in s that matches the pattern p. If no such substring exists, return -1.

Key Points:
• The pattern has exactly 2 wildcards (*)
• Empty substrings are valid matches
• You need the minimum length matching substring

Example: If s = "abcdef" and p = "a*f", then "abcdef" matches but "af" would be shorter if it existed.

Input & Output

example_1.py — Basic Pattern Match

$ Input: s = "abcdef", p = "a*f"

› Output: 6

💡 Note: The pattern 'a*f' means: starts with 'a', ends with 'f', with anything in between. The shortest substring matching this is "abcdef" with length 6.

example_2.py — Multiple Matches

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

› Output: 3

💡 Note: Multiple substrings match 'a*a': "aba" (length 3), "abaca" (length 5), "abacaba" (length 7). The shortest is "aba" with length 3.

example_3.py — No Match Found

$ Input: s = "hello", p = "a*z"

› Output: -1

💡 Note: No substring in "hello" starts with 'a' and ends with 'z', so no match exists.

Visualization

Tap to expand

Understanding the Visualization

Identify Landmarks

Split the pattern 'a*b*c' into prefix 'a', middle section, and suffix 'c'

Find Starting Points

Locate all positions where the prefix 'a' appears in the string

Find Closest Destinations

For each starting point, find the nearest suffix 'c' that comes after it

Calculate Shortest Route

Measure the distance from start of prefix to end of suffix, keep the minimum

Key Takeaway

🎯 Key Insight: The shortest matching substring is determined by finding the closest valid prefix-suffix pair. We don't need to check every possible substring - just find optimal anchor points!

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) substrings × O(n) pattern matching per substring

⚠ Quadratic Growth

Space Complexity

O(1)

Only storing pattern parts and current substring info

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁴
3 ≤ p.length ≤ 100
p contains exactly two '*' characters
s and p consist of lowercase English letters and '*'
The empty substring is considered valid if both prefix and suffix are empty

Asked in

G Google 42 a Amazon 35 ⊞ Microsoft 28 f Meta 22

The optimal approach uses two pointers to efficiently find the shortest matching substring. Split the pattern into prefix and suffix parts, then for each valid prefix position, find the closest suffix position. This gives us O(n²) worst-case time but is much faster in practice than brute force, as we avoid generating unnecessary substrings.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n³)	O(1)	Check every possible substring to see if it matches the pattern
Binary Search on Answer	O(n log n)	O(1)	Binary search on substring length, validate each length for pattern match
Two Pointers (Optimal Pattern Matching)	O(n × m)	O(1)	Find closest valid prefix and suffix positions to minimize substring length

Brute Force (Check All Substrings) — Algorithm Steps

Split pattern p into prefix, suffix (parts before/after the two stars)
Generate all substrings of s from shortest to longest
For each substring, check if it starts with prefix and ends with suffix
Return length of first matching substring (shortest due to order)

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Pattern

Divide pattern 'a*c*f' into prefix 'a', middle '*', suffix 'f'

Generate Substrings

Create all substrings starting from minimum possible length

Match Check

Verify each substring starts with prefix and ends with suffix

Return First Match

First valid match is shortest due to length ordering

Code -

solution.c — C

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

int shortestMatchingSubstring(char* s, char* p) {
    // Find the two asterisks
    char* first_star = strchr(p, '*');
    if (!first_star) return -1;
    
    char* second_star = strchr(first_star + 1, '*');
    if (!second_star) return -1;
    
    // Extract prefix and suffix
    int prefix_len = first_star - p;
    int suffix_len = strlen(second_star + 1);
    
    int n = strlen(s);
    int min_len = prefix_len + suffix_len;
    
    for (int length = min_len; length <= n; length++) {
        for (int start = 0; start <= n - length; start++) {
            // Check prefix
            if (strncmp(s + start, p, prefix_len) == 0 &&
                strncmp(s + start + length - suffix_len, second_star + 1, suffix_len) == 0) {
                return length;
            }
        }
    }
    
    return -1;
}

int main() {
    char s[1000], p[100];
    fgets(s, sizeof(s), stdin);
    fgets(p, sizeof(p), stdin);
    
    // Remove newlines
    s[strcspn(s, "\n")] = 0;
    p[strcspn(p, "\n")] = 0;
    
    printf("%d\n", shortestMatchingSubstring(s, p));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) substrings × O(n) pattern matching per substring

⚠ Quadratic Growth

Space Complexity

O(1)

Only storing pattern parts and current substring info

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁴
3 ≤ p.length ≤ 100
p contains exactly two '*' characters
s and p consist of lowercase English letters and '*'
The empty substring is considered valid if both prefix and suffix are empty

32.5K Views

Medium-High Frequency

~18 min Avg. Time

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

Brute Force (Check All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler