Merge branch 'master' into refactor/HammingDistance

Author: alxkm

.github/CODEOWNERS

@@ -1 +1 @@
-* @yanglbme @vil02 @BamaCharanChhandogi @alxkm
+* @yanglbme @vil02 @BamaCharanChhandogi @alxkm @siriak

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

@@ -6,17 +6,28 @@
  * cover the entire text ?-> matches single characters *-> match the sequence of
  * characters
  *
- * For calculation of Time and Space Complexity. Let N be length of src and M be
- * length of pat
+ * For calculation of Time and Space Complexity. Let N be length of src and M be length of pat
  *
+ * Memoization vs Tabulation : https://www.geeksforgeeks.org/tabulation-vs-memoization/
+ * Question Link : https://practice.geeksforgeeks.org/problems/wildcard-pattern-matching/1
  */
 public final class RegexMatching {
     private RegexMatching() {
     }
 
-    // Method 1: Using Recursion
-    // Time Complexity=0(2^(N+M)) Space Complexity=Recursion Extra Space
-    static boolean regexRecursion(String src, String pat) {
+    /**
+     * Method 1: Determines if the given source string matches the given pattern using a recursive approach.
+     * This method directly applies recursion to check if the source string matches the pattern, considering
+     * the wildcards '?' and '*'.
+     *
+     * Time Complexity: O(2^(N+M)), where N is the length of the source string and M is the length of the pattern.
+     * Space Complexity: O(N + M) due to the recursion stack.
+     *
+     * @param src The source string to be matched against the pattern.
+     * @param pat The pattern containing wildcards ('*' matches a sequence of characters, '?' matches a single character).
+     * @return {@code true} if the source string matches the pattern, {@code false} otherwise.
+     */
+    public static boolean regexRecursion(String src, String pat) {
         if (src.length() == 0 && pat.length() == 0) {
             return true;
         }
@@ -50,8 +61,19 @@ static boolean regexRecursion(String src, String pat) {
         return ans;
     }
 
-    // Method 2: Using Recursion and breaking string using virtual index
-    // Time Complexity=0(2^(N+M)) Space Complexity=Recursion Extra Space
+    /**
+     * Method 2: Determines if the given source string matches the given pattern using recursion.
+     * This method utilizes a virtual index for both the source string and the pattern to manage the recursion.
+     *
+     * Time Complexity: O(2^(N+M)) where N is the length of the source string and M is the length of the pattern.
+     * Space Complexity: O(N + M) due to the recursion stack.
+     *
+     * @param src The source string to be matched against the pattern.
+     * @param pat The pattern containing wildcards ('*' matches a sequence of characters, '?' matches a single character).
+     * @param svidx The current index in the source string.
+     * @param pvidx The current index in the pattern.
+     * @return {@code true} if the source string matches the pattern, {@code false} otherwise.
+     */
     static boolean regexRecursion(String src, String pat, int svidx, int pvidx) {
         if (src.length() == svidx && pat.length() == pvidx) {
             return true;
@@ -83,9 +105,21 @@ static boolean regexRecursion(String src, String pat, int svidx, int pvidx) {
         return ans;
     }
 
-    // Method 3: Top-Down DP(Memoization)
-    // Time Complexity=0(N*M) Space Complexity=0(N*M)+Recursion Extra Space
-    static boolean regexRecursion(String src, String pat, int svidx, int pvidx, int[][] strg) {
+    /**
+     * Method 3: Determines if the given source string matches the given pattern using top-down dynamic programming (memoization).
+     * This method utilizes memoization to store intermediate results, reducing redundant computations and improving efficiency.
+     *
+     * Time Complexity: O(N * M), where N is the length of the source string and M is the length of the pattern.
+     * Space Complexity: O(N * M) for the memoization table, plus additional space for the recursion stack.
+     *
+     * @param src The source string to be matched against the pattern.
+     * @param pat The pattern containing wildcards ('*' matches a sequence of characters, '?' matches a single character).
+     * @param svidx The current index in the source string.
+     * @param pvidx The current index in the pattern.
+     * @param strg A 2D array used for memoization to store the results of subproblems.
+     * @return {@code true} if the source string matches the pattern, {@code false} otherwise.
+     */
+    public static boolean regexRecursion(String src, String pat, int svidx, int pvidx, int[][] strg) {
         if (src.length() == svidx && pat.length() == pvidx) {
             return true;
         }
@@ -120,8 +154,18 @@ static boolean regexRecursion(String src, String pat, int svidx, int pvidx, int[
         return ans;
     }
 
-    // Method 4: Bottom-Up DP(Tabulation)
-    // Time Complexity=0(N*M) Space Complexity=0(N*M)
+    /**
+     * Method 4: Determines if the given source string matches the given pattern using bottom-up dynamic programming (tabulation).
+     * This method builds a solution iteratively by filling out a table, where each cell represents whether a substring
+     * of the source string matches a substring of the pattern.
+     *
+     * Time Complexity: O(N * M), where N is the length of the source string and M is the length of the pattern.
+     * Space Complexity: O(N * M) for the table used in the tabulation process.
+     *
+     * @param src The source string to be matched against the pattern.
+     * @param pat The pattern containing wildcards ('*' matches a sequence of characters, '?' matches a single character).
+     * @return {@code true} if the source string matches the pattern, {@code false} otherwise.
+     */
     static boolean regexBU(String src, String pat) {
         boolean[][] strg = new boolean[src.length() + 1][pat.length() + 1];
         strg[src.length()][pat.length()] = true;
@@ -153,15 +197,4 @@ static boolean regexBU(String src, String pat) {
         }
         return strg[0][0];
     }
-
-    public static void main(String[] args) {
-        String src = "aa";
-        String pat = "*";
-        System.out.println("Method 1: " + regexRecursion(src, pat));
-        System.out.println("Method 2: " + regexRecursion(src, pat, 0, 0));
-        System.out.println("Method 3: " + regexRecursion(src, pat, 0, 0, new int[src.length()][pat.length()]));
-        System.out.println("Method 4: " + regexBU(src, pat));
-    }
 }
-// Memoization vs Tabulation : https://www.geeksforgeeks.org/tabulation-vs-memoization/
-// Question Link : https://practice.geeksforgeeks.org/problems/wildcard-pattern-matching/1

src/main/java/com/thealgorithms/stacks/InfixToPostfix.java

@@ -1,19 +1,15 @@
 package com.thealgorithms.stacks;
 
 import java.util.Stack;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 public final class InfixToPostfix {
     private InfixToPostfix() {
     }
 
-    public static void main(String[] args) throws Exception {
-        assert "32+".equals(infix2PostFix("3+2"));
-        assert "123++".equals(infix2PostFix("1+(2+3)"));
-        assert "34+5*6-".equals(infix2PostFix("(3+4)*5-6"));
-    }
-
     public static String infix2PostFix(String infixExpression) throws Exception {
-        if (!BalancedBrackets.isBalanced(infixExpression)) {
+        if (!BalancedBrackets.isBalanced(filterBrackets(infixExpression))) {
             throw new Exception("invalid expression");
         }
         StringBuilder output = new StringBuilder();
@@ -55,4 +51,10 @@ private static int precedence(char operator) {
             return -1;
         }
     }
+
+    private static String filterBrackets(String input) {
+        Pattern pattern = Pattern.compile("[^(){}\\[\\]<>]");
+        Matcher matcher = pattern.matcher(input);
+        return matcher.replaceAll("");
+    }
 }

src/main/java/com/thealgorithms/strings/LongestPalindromicSubstring.java

@@ -1,44 +1,31 @@
 package com.thealgorithms.strings;
 
-// Longest Palindromic Substring
-import java.util.Scanner;
-
 final class LongestPalindromicSubstring {
     private LongestPalindromicSubstring() {
     }
 
-    public static void main(String[] args) {
-        Solution s = new Solution();
-        String str = "";
-        Scanner sc = new Scanner(System.in);
-        System.out.print("Enter the string: ");
-        str = sc.nextLine();
-        System.out.println("Longest substring is : " + s.longestPalindrome(str));
-        sc.close();
-    }
-}
-
-class Solution {
-
-    public String longestPalindrome(String s) {
-        if (s == null || s.length() == 0) {
+    /**
+     * Finds the longest palindromic substring in the given string.
+     *
+     * @param s the input string
+     * @return the longest palindromic substring
+     */
+    public static String longestPalindrome(String s) {
+        if (s == null || s.isEmpty()) {
             return "";
         }
-        int n = s.length();
         String maxStr = "";
-        for (int i = 0; i < n; ++i) {
-            for (int j = i; j < n; ++j) {
-                if (isValid(s, i, j)) {
-                    if (j - i + 1 > maxStr.length()) { // update maxStr
-                        maxStr = s.substring(i, j + 1);
-                    }
+        for (int i = 0; i < s.length(); ++i) {
+            for (int j = i; j < s.length(); ++j) {
+                if (isValid(s, i, j) && (j - i + 1 > maxStr.length())) {
+                    maxStr = s.substring(i, j + 1);
                 }
             }
         }
         return maxStr;
     }
 
-    private boolean isValid(String s, int lo, int hi) {
+    private static boolean isValid(String s, int lo, int hi) {
         int n = hi - lo + 1;
         for (int i = 0; i < n / 2; ++i) {
             if (s.charAt(lo + i) != s.charAt(hi - i)) {

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

@@ -0,0 +1,43 @@
+package com.thealgorithms.dynamicprogramming;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+public class RegexMatchingTest {
+
+    private record RegexTestCase(String s, String p, boolean expected) {
+    }
+
+    private static Stream<Arguments> provideTestCases() {
+        return Stream.of(Arguments.of(new RegexTestCase("aa", "*", true)), Arguments.of(new RegexTestCase("aa", "a*", true)), Arguments.of(new RegexTestCase("aa", "a", false)), Arguments.of(new RegexTestCase("cb", "?b", true)), Arguments.of(new RegexTestCase("cb", "?a", false)),
+            Arguments.of(new RegexTestCase("adceb", "*a*b", true)), Arguments.of(new RegexTestCase("acdcb", "a*c?b", false)), Arguments.of(new RegexTestCase("", "*", true)), Arguments.of(new RegexTestCase("", "", true)));
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideTestCases")
+    void testRegexRecursionMethod1(RegexTestCase testCase) {
+        assertEquals(testCase.expected(), RegexMatching.regexRecursion(testCase.s(), testCase.p()));
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideTestCases")
+    void testRegexRecursionMethod2(RegexTestCase testCase) {
+        assertEquals(testCase.expected(), RegexMatching.regexRecursion(testCase.s(), testCase.p(), 0, 0));
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideTestCases")
+    void testRegexRecursionMethod3(RegexTestCase testCase) {
+        assertEquals(testCase.expected(), RegexMatching.regexRecursion(testCase.s(), testCase.p(), 0, 0, new int[testCase.s().length()][testCase.p().length()]));
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideTestCases")
+    void testRegexBottomUp(RegexTestCase testCase) {
+        assertEquals(testCase.expected(), RegexMatching.regexBU(testCase.s(), testCase.p()));
+    }
+}

src/test/java/com/thealgorithms/stacks/InfixToPostfixTest.java

@@ -0,0 +1,33 @@
+package com.thealgorithms.stacks;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class InfixToPostfixTest {
+
+    @ParameterizedTest
+    @MethodSource("provideValidExpressions")
+    void testValidExpressions(String infix, String expectedPostfix) throws Exception {
+        assertEquals(expectedPostfix, InfixToPostfix.infix2PostFix(infix));
+    }
+
+    private static Stream<Arguments> provideValidExpressions() {
+        return Stream.of(Arguments.of("3+2", "32+"), Arguments.of("1+(2+3)", "123++"), Arguments.of("(3+4)*5-6", "34+5*6-"));
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideInvalidExpressions")
+    void testInvalidExpressions(String infix, String expectedMessage) {
+        Exception exception = assertThrows(Exception.class, () -> InfixToPostfix.infix2PostFix(infix));
+        assertEquals(expectedMessage, exception.getMessage());
+    }
+
+    private static Stream<Arguments> provideInvalidExpressions() {
+        return Stream.of(Arguments.of("((a+b)*c-d", "invalid expression"));
+    }
+}

src/test/java/com/thealgorithms/strings/LongestPalindromicSubstringTest.java

@@ -0,0 +1,21 @@
+package com.thealgorithms.strings;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class LongestPalindromicSubstringTest {
+
+    @ParameterizedTest
+    @MethodSource("provideTestCasesForLongestPalindrome")
+    void testLongestPalindrome(String input, String expected) {
+        assertEquals(expected, LongestPalindromicSubstring.longestPalindrome(input));
+    }
+
+    private static Stream<Arguments> provideTestCasesForLongestPalindrome() {
+        return Stream.of(Arguments.of("babad", "bab"), Arguments.of("cbbd", "bb"), Arguments.of("a", "a"), Arguments.of("", ""), Arguments.of("abc", "a"), Arguments.of(null, ""), Arguments.of("aaaaa", "aaaaa"));
+    }
+}