# Solving Leetcode Interviews in Seconds with AI: Shortest Matching Substring


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3455" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> You are given a string s and a pattern string p, where p contains exactly two '*' characters. The '*' in p matches any sequence of zero or more characters. Return the length of the shortest substring in s that matches p. If there is no such substring, return -1. Note: The empty substring is considered valid.   Example 1:  Input: s = "abaacbaecebce", p = "ba*c*ce" Output: 8 Explanation: The shortest matching substring of p in s is "baecebce".  Example 2:  Input: s = "baccbaadbc", p = "cc*baa*adb" Output: -1 Explanation: There is no matching substring in s.  Example 3:  Input: s = "a", p = "**" Output: 0 Explanation: The empty substring is the shortest matching substring.  Example 4:  Input: s = "madlogic", p = "*adlogi*" Output: 6 Explanation: The shortest matching substring of p in s is "adlogi".    Constraints:  1 <= s.length <= 105 2 <= p.length <= 105 s contains only lowercase English letters. p contains only lowercase English letters and exactly two '*'.  

	# Explanation
	Here's the breakdown of the approach and the code:

*   **Key Idea:** Split the pattern `p` into three parts based on the two '*' characters.  Search for the first occurrence of the first part, then the last occurrence of the last part *after* the first part, and finally check if the middle part can bridge the gap.
*   **Optimization:** Use Python's built-in string functions like `find()` and `rfind()` for efficient substring searching. Handle edge cases and invalid patterns gracefully.
*   **Edge case**: When the pattern is "**", return 0.

*   **Complexity:**
    *   Runtime: O(n), where n is the length of the string `s`.
    *   Storage: O(1) (constant space).

	
	# Code
	```python
	def shortest_substring_match(s: str, p: str) -> int:
    """
    Finds the length of the shortest substring in s that matches p, where p contains exactly two '*' characters.
    The '*' in p matches any sequence of zero or more characters.
    """
    if p == "**":
        return 0

    star_count = p.count('*')
    if star_count != 2:
        return -1

    parts = p.split('*')
    if len(parts) != 3:
        return -1

    first_part = parts[0]
    middle_part = parts[1]
    last_part = parts[2]

    first_index = s.find(first_part)
    if first_index == -1:
        return -1

    last_index = s.rfind(last_part)
    if last_index == -1:
        return -1
    
    if first_index > last_index:
        return -1

    potential_middle = s[first_index + len(first_part):last_index]

    # Check if middle part can bridge the gap
    
    # if middle_part == "":
    #     return len(first_part) + len(potential_middle) + len(last_part)

    # It seems like any potential middle will work, 
    # because the '*' characters could match the empty string if needed.
    
    if first_index + len(first_part) <= last_index:
        return len(first_part) + len(potential_middle) + len(last_part)
    
    return -1
	```