feat: add Regular Expression Matching algorithm using DP

Author: kokatesaurabh

src/main/java/com/thealgorithms/dynamicprogramming/RegularExpressionMatching.java

@@ -1,38 +1,37 @@
 package com.thealgorithms.dynamicprogramming;
 
+/**
+ * Class for Regular Expression Matching using Dynamic Programming.
+ */
 public class RegularExpressionMatching {
 
     /**
-     * Function to implement regex matching with '.' and '*'.
-     * '.' Matches any single character
-     * '*' Matches zero or more of the preceding element
+     * Determines if the input string matches the given pattern.
      *
-     * @param s input string
-     * @param p pattern string
+     * @param s the input string
+     * @param p the pattern string (may contain '.' and '*')
      * @return true if the string matches the pattern, false otherwise
      */
-    public boolean isMatch(String s, String p) {
-        Boolean[][] memo = new Boolean[s.length() + 1][p.length() + 1];
+    public boolean isMatch(final String s, final String p) {
+        final Boolean[][] memo = new Boolean[s.length() + 1][p.length() + 1];
         return dp(0, 0, s, p, memo);
     }
 
-    private boolean dp(int i, int j, String s, String p, Boolean[][] memo) {
-        if (memo[i][j] != null) return memo[i][j];
+    private boolean dp(final int i, final int j, final String s, final String p, final Boolean[][] memo) {
+        if (memo[i][j] != null) {
+            return memo[i][j];
+        }
 
-        boolean ans;
+        final boolean ans;
         if (j == p.length()) {
-            // If pattern is finished, string must also be finished
             ans = (i == s.length());
         } else {
-            // Check if first character matches
-            boolean firstMatch = (i < s.length() &&
-                    (s.charAt(i) == p.charAt(j) || p.charAt(j) == '.'));
+            final boolean firstMatch = (i < s.length() && (s.charAt(i) == p.charAt(j) || p.charAt(j) == '.'));
 
-            // Handle '*' in the pattern
             if (j + 1 < p.length() && p.charAt(j + 1) == '*') {
                 // Two options:
-                // 1. Skip the "x*" in the pattern
-                // 2. If firstMatch is true, consume one char from string
+                // 1. Skip the pattern with '*'
+                // 2. Use '*' to match one character
                 ans = dp(i, j + 2, s, p, memo) || (firstMatch && dp(i + 1, j, s, p, memo));
             } else {
                 ans = firstMatch && dp(i + 1, j + 1, s, p, memo);
@@ -42,35 +41,4 @@ private boolean dp(int i, int j, String s, String p, Boolean[][] memo) {
         memo[i][j] = ans;
         return ans;
     }
-
-    // -----------------------
-    // Main function with test cases
-    // -----------------------
-    public static void main(String[] args) {
-        RegularExpressionMatching solution = new RegularExpressionMatching();
-
-        String[][] testCases = {
-                {"aa", "a", "false"},
-                {"aa", "a*", "true"},
-                {"ab", ".*", "true"},
-                {"mississippi", "mis*is*p*.", "false"},
-                {"ab", ".*c", "false"},
-                {"aaa", "a*a", "true"},
-                {"aab", "c*a*b", "true"},
-                {"", ".*", "true"},
-                {"", "", "true"},
-                {"abcd", "d*", "false"}
-        };
-
-        System.out.println("Testing Regular Expression Matching (DP with Memoization)\n");
-
-        for (String[] test : testCases) {
-            String s = test[0];
-            String p = test[1];
-            boolean expected = Boolean.parseBoolean(test[2]);
-            boolean result = solution.isMatch(s, p);
-            System.out.printf("Input: s = \"%s\", p = \"%s\" | Output: %b | Expected: %b | %s\n",
-                    s, p, result, expected, (result == expected ? "✅" : "❌"));
-        }
-    }
-}
+}

src/test/java/com/thealgorithms/dynamicprogramming/RegularExpressionMatchingTest.java

@@ -0,0 +1,28 @@
+package com.thealgorithms.dynamicprogramming;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Test class for RegularExpressionMatching.
+ */
+public class RegularExpressionMatchingTest {
+
+    @Test
+    public void testBasicCases() {
+        final RegularExpressionMatching matcher = new RegularExpressionMatching();
+        
+        // Test cases from the problem
+        assertFalse(matcher.isMatch("aa", "a"));
+        assertTrue(matcher.isMatch("aa", "a*"));
+        assertTrue(matcher.isMatch("ab", ".*"));
+        assertFalse(matcher.isMatch("mississippi", "mis*is*p*."));
+        assertFalse(matcher.isMatch("ab", ".*c"));
+        assertTrue(matcher.isMatch("aaa", "a*a"));
+        assertTrue(matcher.isMatch("aab", "c*a*b"));
+        assertTrue(matcher.isMatch("", ".*"));
+        assertTrue(matcher.isMatch("", ""));
+        assertFalse(matcher.isMatch("abcd", "d*"));
+    }
+}