LeetCode has a Medium coding Problem in Its’ Algorithm Section “Regular Expression Matching Leetcode Python”. Today We are going to solve this problem. LeetCode Link of the Problem is HERE.
Question
Given an input string s and a pattern p, implement regular expression matching with support for '.' and '*' where:
'.'Matches any single character.'*'Matches zero or more of the preceding element.
The matching should cover the entire input string (not partial).
Examples
Input: s = “aa”, p = “a”
Output: false
Explanation: “a” does not match the entire string “aa”.
Input: s = “aa”, p = “a” Output: true Explanation: ‘‘ means zero or more of the preceding element, ‘a’. Therefore, by repeating ‘a’ once, it becomes “aa”.
Input: s = “ab”, p = “.” Output: true Explanation: “.” means “zero or more (*) of any character (.)”.
Constraints:
1 <= s.length <= 201 <= p.length <= 30scontains only lowercase English letters.pcontains only lowercase English letters,'.', and'*'.- It is guaranteed for each appearance of the character
'*', there will be a previous valid character to match.
Solution to Regular Expression Matching Leetcode Python
The Skeleton code given in Leetcode Python is
Firstly, check for the base condition. Suppose that a given input string is empty and the pattern is also empty then the function must return True. And if the String is nonempty but the Pattern is empty then the function must return False.
Secondly, Create a boolean 2D dp array with sizes as boolean[][] dp = new boolean[s.length() + 1][p.length() + 1]. We’ve added an additional 1 to account for the possibility that one or both of the strings are empty.It’s a match if both strings are empty, therefore dp[0][0] = true.
Let’s state s[i – 1] == p[j – 1] for non-empty strings, which indicates the I – 1)th and (j – 1)th characters are the same. This implies we must determine whether or not the remaining strings are a match. If they match, the current substrings will match as well; otherwise, they will not, i.e., dp[i][j] = dp[i – 1][j – 1]. Because we’re presuming our strings start at index 1, we’re using the I – 1)th and (j – 1)th characters to offset empty strings.
Complete Solution
class Solution(object):
def isMatch(self, s, p):
“””
:type s: str
:type p: str
:rtype: bool
“””
rows, columns = (len(s), len(p))
# Base conditions
if rows == 0 and columns == 0:
return True
if columns == 0:
return False
# DP array
dp = [[False for j in range(columns + 1)] for i in range(rows + 1)]
# Since empty string and empty pattern are a match
# print(dp)
dp[0][0] = True
# Deals with patterns containing *
for i in range(2, columns + 1):
if p[i – 1] == ‘‘: dp[0][i] = dp[0][i – 2] # For remaining characters for i in range(1, rows + 1): for j in range(1, columns + 1): if s[i – 1] == p[j – 1] or p[j – 1] == ‘.’: dp[i][j] = dp[i – 1][j – 1] elif j > 1 and p[j – 1] == ‘‘:
dp[i][j] = dp[i][j – 2]
if p[j – 2] == ‘.’ or p[j – 2] == s[i – 1]:
dp[i][j] = dp[i][j] or dp[i – 1][j]
return dp[rows][columns]
READ MORE
Python-related posts Visit HERE
C++ related posts Visit HERE
Databases related posts Visit HERE
Data Structures related posts visit HERE
Algorithms related posts visit HERE
Data Science related posts visit HERE
import re
class Solution:
def isMatch(self, s: str, p: str) -> bool:
if re.compile(p+’$’).match(s):
return True
return False
🙂 thank me later
Wow!