# Wildcard Pattern Matching

Posted: 13 Sep, 2020
Difficulty: Hard

## PROBLEM STATEMENT

#### The wildcard pattern can include the characters ‘?’ and ‘*’

`````` ‘?’ – matches any single character
‘*’ – Matches any sequence of characters(sequence can be of length 0 or more)
``````
##### Input Format:
``````The first line contains an Integer 'T' which denotes the number of test cases/queries to be run.
Then the test cases follow.

The first line of input for each test case/query contains a string representing the wildcard pattern.

The second line of input for each test case/query contains a string representing the text.
``````
##### Output Format:
``````For each test case, print ‘True’ if the text matches the pattern, print ‘False’ otherwise(without quotes).

Output for every test case will be printed in a separate line.
``````
##### Note:
``````You do not need to print anything, it has already been taken care of. Just implement the function.
``````
##### Constraints:
``````1 <= T <= 100
1 <= N <= 200
1 <= M <= 200

Where 'N' denotes the length of 'TEXT' and 'M' denotes the length of 'PATTERN'.

'TEXT' and 'PATTERN' contain only lowercase letters and patterns may contain special characters ‘*’ and ‘?’

Time Limit: 1sec
`````` Approach 1

We will try to explore all the possibilities using the recursion.

Let’s say we have a recursive function ‘REC’ who has two arguments IDX and IDY where IDX represents the index in the text string and IDY represents the index in pattern string and its return type is boolean. Initially, we will call the rec with IDX =  N and IDY = M where N is the size of the text string and M is the size of the pattern string.

• If IDX == 0 && IDY == 0
• It means we have reached end of both text and pattern so return true
• If IDY == 0
• It means we have reached the end of the pattern but there are some characters left in the text so we should return false.
• If IDX == 0
• It means we have reached the end of the text but there are some characters left in the pattern so we should check if all the left characters are ‘*’ then return true otherwise return false.

We have taken care of the base cases now we need recursive relation to explore the cases. Create a variable RET = 0 to store the answer.

• If TEXT[IDX-1] == PATTERN[IDY-1] || PATTERN[IDY-1] == ‘?’
• RET |= REC(IDX-1,IDY-1)
• It means if the character at IDX-1 of TEXT and IDY-1 of pattern matches we can reduce the length of both by 1.
• If PATTERN[IDY-1] == ‘*’
• RET |= REC(IDX-1,IDy) // Matches current character of text and ‘*’ can match more characters of the text.
• RET |= REC(IDX,IDY-1) // Stopped matching the characters with ‘*’
• Return the RET which has our required answer.