wildcard matching

backtracking/wildcard_matching.cpp

@@ -0,0 +1,143 @@
+/**
+ * @file
+ * @brief Implementation of the [Wildcard Matching](https://www.geeksforgeeks.org/wildcard-pattern-matching/) problem.
+ * @details
+ * Problem Statement: 
+ * Given an matching string and a pattern, implement wildcard pattern matching with support for '?' and '*'. '?' Matches any single character. '*' Matches any sequence of characters (including the empty sequence). The matching should cover the entire matching string (not partial). Task is to determine if the pattern matches with the matching string
+ * @author [Swastika Gupta](https://github.com/Swastyy)
+ */
+
+#include <cassert>   /// for assert
+#include <iostream>  /// for IO operations
+#include <vector>    /// for std::vector
+
+/**
+ * @namespace backtracking
+ * @brief Backtracking algorithms
+ */
+namespace backtracking {
+/**
+ * @namespace wildcard_matching
+ * @brief Functions for the [Wildcard Matching](https://www.geeksforgeeks.org/wildcard-pattern-matching/) problem.
+ */
+namespace wildcard_matching {
+/**
+ * @brief The main function implements if pattern can be matched with given string
+ * @param s is the given matching string
+ * @param p is the given pattern
+ * @param pos1 is the starting index
+ * @param pos2 is the last index
+ * @returns 1 if pattern matches with matching string otherwise 0
+ */
+std::vector<std::vector<int>>dpTable(1000, std::vector<int>(1000, -1));
+int32_t wildcard_matching(std::string s, std::string p, int pos1, int pos2)
+{       
+        int n = s.length();
+        int m = p.length();
+	    // matching is successfull if both strings are done
+        if(pos1 == n && pos2 == m)
+		    {
+            return 1;
+		    }
+
+		// matching is unsuccessfull if pattern is not finished but matching string is
+        if(pos1 != n && pos2 == m)
+		    {
+            return 0;
+		    }
+
+		// all the remaining characters of patterns must be * inorder to match with finished string
+        if(pos1 == n && pos2 != m)
+        {
+            while(pos2 < m && p[pos2] == '*')
+			      {
+                pos2++;
+			      }
+
+            return pos2 == m;
+        }
+
+		// if already calculted for these positions
+        if(dpTable[pos1][pos2] != -1)
+		    {
+            return dpTable[pos1][pos2];
+		    }
+
+		// if the characters are same just go ahead in both the string
+        if(s[pos1] == p[pos2])
+		    {
+            return dpTable[pos1][pos2] = wildcard_matching(s, p, pos1 + 1, pos2 + 1);
+		    }
+
+        else
+        {
+		// can only single character
+            if(p[pos2] == '?')
+			      {
+                return dpTable[pos1][pos2] = wildcard_matching(s, p, pos1 + 1, pos2 + 1);
+			      }
+			// have choice either to match one or more charcters
+            else if(p[pos2] == '*')
+			      {
+                return dpTable[pos1][pos2] = wildcard_matching(s, p, pos1, pos2 + 1) || wildcard_matching(s, p, pos1 + 1, pos2);
+			      }
+			// not possible to match
+            else
+			      {
+                return dpTable[pos1][pos2] = 0;
+			      }
+        }
+}
+
+}  // namespace wildcard_matching
+}  // namespace backtracking
+
+/**
+ * @brief Test implementations
+ * @returns void
+ */
+static void test() {
+    // 1st test
+    std::cout << "1st test ";
+    std::string matching1 = "baaabab";
+    std::string pattern1 = "*****ba*****ab";
+    assert(backtracking::wildcard_matching::wildcard_matching(matching1, pattern1, 0, 0) == 1);  // here the pattern matches with given string
+    std::cout << "passed" << std::endl;
+
+    // 2nd test
+    std::cout << "2nd test ";
+    std::string matching2 = "baaabab";
+    std::string pattern2 = "ba*****ab";
+    assert(backtracking::wildcard_matching::wildcard_matching(matching2, pattern2, 0, 0) == 1);  // here the pattern matches with given string
+    std::cout << "passed" << std::endl;
+
+    // 3rd test
+    std::cout << "3rd test ";
+    std::string matching3 = "baaabab";
+    std::string pattern3 = "ba*ab";
+    assert(backtracking::wildcard_matching::wildcard_matching(matching3, pattern3, 0, 0) == 1);  // here the pattern matches with given string
+    std::cout << "passed" << std::endl;
+
+    // 4th test
+    std::cout << "4th test ";
+    std::string matching4 = "baaabab";
+    std::string pattern4 = "a*ab";
+    assert(backtracking::wildcard_matching::wildcard_matching(matching4, pattern4, 0, 0) == 1);  // here the pattern matches with given string
+    std::cout << "passed" << std::endl;
+
+    // Test 5
+    std::cout << "5th test ";
+    std::string matching5 = "baaabab";
+    std::string pattern5 = "aa?ab";
+    assert(backtracking::wildcard_matching::wildcard_matching(matching5, pattern5, 0, 0) == 1);  // here the pattern matches with given string
+    std::cout << "passed" << std::endl;
+}
+
+/**
+ * @brief Main function
+ * @returns 0 on exit
+ */
+int main() {
+    test();  // run self-test implementations
+    return 0;
+}