feat(strings, backtracking): remove invalid parenthesis

Author: BrianLusina

pystrings/lexicographically_largest_string/test_lexicographically_largest_string.py

@@ -2,7 +2,7 @@
 from parameterized import parameterized
 from pystrings.lexicographically_largest_string import (
     lexicographically_largest_string_from_box,
-    lexicographically_largest_string_from_box_2
+    lexicographically_largest_string_from_box_2,
 )
 
 

pystrings/parenthesis/__init__.py

@@ -1,10 +1,10 @@
 import unittest
 
-from pystrings.balanced_paren import balanced_parens
+from pystrings.parenthesis.balanced_paren import balanced_parens
 
 
 class BalancedParensTestCase(unittest.TestCase):
-    def sample_tests(self):
+    def test_sample(self):
         for n, exp in [
             [0, [""]],
             [1, ["()"]],
@@ -15,7 +15,7 @@ def sample_tests(self):
             actual.sort()
             self.assertEqual(actual, exp)
 
-    def random_tests(self):
+    def test_random(self):
         def ref_sol(n):
             return list(dfs([], 0, 0, n))
 
@@ -37,14 +37,14 @@ def dfs(s, open_count, close_count, max_p):
         rng = list(range(13))
         shuffle(rng)
         for n in rng:
-            exp = ref_sol(n)
-            act = balanced_parens(n)
-            exp.sort()
-            act.sort()
-            if len(exp) > 1000:
-                self.assertEqual(exp == act, "Nope...(n={})".format(n))
+            expected = ref_sol(n)
+            actual = balanced_parens(n)
+            expected.sort()
+            actual.sort()
+            if len(expected) > 1000:
+                self.assertEqual(expected, actual, "Nope...(n={})".format(n))
             else:
-                self.assertEqual(act, exp)
+                self.assertEqual(expected, actual)
 
 
 if __name__ == "__main__":

pystrings/balanced_paren/README.md …ngs/parenthesis/balanced_paren/README.mdpystrings/balanced_paren/README.md renamed to pystrings/parenthesis/balanced_paren/README.md pystrings/balanced_paren/README.md renamed to pystrings/parenthesis/balanced_paren/README.md

@@ -1,3 +1,5 @@
+# Parenthesis Matcher
+
 I like parentheticals (a lot).
 "Sometimes (when I nest them (my parentheticals) too much (like this (and this))) they get confusing."
 
@@ -20,8 +22,10 @@ keep a count of how many additional "(" we find as open_nested_parens. When we f
 open_nested_parens. If we find a ")" and open_nested_parens is 0, we know that ")" closes our initial "(", so we return
 its position.
 
+```python
 def get_closing_paren(sentence, opening_paren_index):
-open_nested_parens = 0 position = opening_paren_index + 1
+    open_nested_parens = 0
+    position = opening_paren_index + 1
 
     while position <= len(sentence) - 1:
         char = sentence[position]
@@ -37,6 +41,7 @@ open_nested_parens = 0 position = opening_paren_index + 1
         position += 1
 
     raise Exception("No closing parenthesis :(")
+```
 
 Complexity O(n) time, where nn is the number of chars in the string. O(1)O(1) space.
 

pystrings/balanced_paren/__init__.py …s/parenthesis/balanced_paren/__init__.pypystrings/balanced_paren/__init__.py renamed to pystrings/parenthesis/balanced_paren/__init__.py pystrings/balanced_paren/__init__.py renamed to pystrings/parenthesis/balanced_paren/__init__.py

@@ -1,4 +1,4 @@
-def closing_paren(sentence, open_paren_index):
+def closing_paren(sentence: str, open_paren_index: int) -> int:
     """
 
     :param: sentence the sentence to search through

…gs/balanced_paren/test_balanced_paren.py …is/balanced_paren/test_balanced_paren.pypystrings/balanced_paren/test_balanced_paren.py renamed to pystrings/parenthesis/balanced_paren/test_balanced_paren.py pystrings/balanced_paren/test_balanced_paren.py renamed to pystrings/parenthesis/balanced_paren/test_balanced_paren.py

@@ -0,0 +1,102 @@
+# Remove Invalid Parentheses
+
+You are given a string, `s`, that contains:
+- Lowercase English letters
+- Opening '(' and closing ')' parentheses
+
+A string is considered valid if:
+
+1. All opening parentheses '(' are closed properly by a matching ')'.
+2. The parentheses are in the correct order and nesting. 
+3. Letters can appear anywhere and do not affect validity.
+
+Return all possible valid strings that can be formed by removing the minimum number of invalid parentheses. The answer 
+must be a list of unique strings, in any order.
+
+**Constraints**
+
+- 1 ≤ `s.length` ≤ 25
+- `s` consists of lowercase English letters and parentheses `'('` and `')'`. 
+- There will be at most `20` parentheses in `s`.
+
+## Examples
+
+![Example 1](./images/examples/remove_invalid_parenthesis_example_1.png)
+![Example 2](./images/examples/remove_invalid_parenthesis_example_2.png)
+![Example 3](./images/examples/remove_invalid_parenthesis_example_3.png)
+![Example 4](./images/examples/remove_invalid_parenthesis_example_4.png)
+
+## Solution
+
+The algorithm aims to generate all possible valid strings by removing the minimum number of invalid parentheses. It 
+starts with a preprocessing step to determine how many opening and closing parentheses need to be removed. As it scans 
+the string, it increments a counter for each opening parenthesis. For each closing parenthesis, it tries to match it 
+with an opening one. If no match is found, it marks the closing parenthesis as unmatched. This ensures the algorithm 
+knows the minimum number of each type of parenthesis to remove.
+
+Once the number of invalid parentheses is known, the algorithm uses recursive backtracking to explore all valid 
+combinations. It processes the string one character at a time and considers several choices:
+
+- If the character is an opening parenthesis (, the algorithm considers two choices: skip it to reduce the number of 
+  unmatched openings, or add it to the expression and increase the open count.
+
+- If it’s a closing parenthesis ), it can be skipped to reduce unmatched closings, or added to the expression—but only 
+  if more opening parentheses are already added, to keep the expression balanced.
+
+- If it’s a non-parenthesis character, it is always added to the current expression.
+
+The recursion continues until the end of the string is reached. At that point, if the number of opening and closing 
+parentheses is equal (i.e., the expression is balanced) and no more removals are needed, the expression is added to a 
+result set to ensure uniqueness. After exploring all possibilities, the algorithm returns all unique valid expressions 
+as a list.
+
+The steps of the algorithm are as follows:
+
+1. Count the minimum invalid parentheses to remove:
+   - Initialize two counters, `left_to_remove` (Number of extra '(' to remove) and `right_to_remove` (Number of extra 
+     `')'` to remove).
+   - Iterate through the string:
+     - If the character is `'('`, increment `left_to_remove`.
+     - If the character is `')'`:
+       - If `left_to_remove` > 0, a matching '(' exists, so decrement `left_to_remove`.
+       - Else, increment `right_to_remove` (unmatched right parenthesis).
+
+2. We define a recursive helper function, `backtrack(index, open_count, close_count, path, left_remain, right_remain)` 
+   to explore all valid combinations of the input string. index is the current position in the string. `open_count` and 
+   `close_count` track the number of '(' and ')' in the current path to maintain balance. path holds the built string 
+so far. `left_remain` and `right_remain` indicate how many `'('` and `')'` can still be removed to form a valid expression.
+
+   - When the end of the string is reached (i.e., `index == len(s)`), check if no removals remain (`left_remain == 0` and 
+   `right_remain == 0`) and the parentheses are balanced (`open_count == close_count`). If so, add the current path to 
+     the result set.
+   - Recursive case: At each character `char = s[index]`:
+     - If `char == '('`:
+       - Option to remove it (if `left_remain > 0`):
+         - Recurse without adding '(', decrementing `left_remain`.
+       - Option to keep it:
+         - Recurse adding `'('` to path, incrementing `open_count`.
+     - If `char == ')'`:
+       - Option to remove it (if `right_remain > 0`):
+         - Recurse without adding `')'`, decrementing `right_remain`. 
+       - Option to keep it:
+         - Only if `close_count < open_count` (to ensure balance). 
+         - Recurse adding `')'`, incrementing `close_count`.
+
+     - If char is not a parenthesis:
+       - Always keep it and recurse with the character added to `path`.
+
+3. Call `backtrack(0, 0, 0, '', left_to_remove, right_to_remove)` to begin from index 0 and an empty path.
+4. Convert the result set `result` to a list and return it.
+
+### Time Complexity
+
+At each step of the algorithm, a parenthesis can either be removed or kept, which results in two choices per parenthesis. 
+Therefore, for a string with `n` parentheses, the total number of combinations explored by the backtracking algorithm 
+can grow exponentially, leading to a branching factor of `O(2^n)`. Since letters are always included without affecting 
+the decision tree, they do not contribute to the branching complexity. As a result, the overall time complexity of the 
+algorithm in the worst case is `O(2^n)`.
+
+### Space Complexity
+
+The space complexity of the above solution is `O(n)`, where `n` is the length of the input string because the recursive 
+call stack in the backtracking algorithm can reach a depth of `n`.

pystrings/paren_matcher/README.md …ings/parenthesis/paren_matcher/README.mdpystrings/paren_matcher/README.md renamed to pystrings/parenthesis/paren_matcher/README.md pystrings/paren_matcher/README.md renamed to pystrings/parenthesis/paren_matcher/README.md

@@ -0,0 +1,137 @@
+from typing import List, Set, Deque
+
+
+def is_valid(input_str: str) -> bool:
+    """
+    Check if a string has a valid parenthesis structure. Letters are ignored in validation
+    """
+    # count tracks the number of open parenthesis
+    count = 0
+    for char in input_str:
+        if char == "(":
+            count += 1
+        elif char == ")":
+            count -= 1
+            # if the count goes to negative, we have an ')' without an open '('
+            if count < 0:
+                return False
+    # valid only if all '(' are closed i.e. the count is 0
+    return count == 0
+
+
+def remove_invalid_parentheses(s: str) -> List[str]:
+    # The set 'level' stores all unique strings for the current number of removals.
+    # We start with the original string.
+    level: Set[str] = {s}
+
+    while True:
+        valid_strings = []
+
+        # Check all strings in the current level
+        for string in level:
+            if is_valid(string):
+                valid_strings.append(string)
+
+        # If we found any valid strings in this level, return them.
+        # Because it's BFS, these are guaranteed to be the "minimum removals".
+        if valid_strings:
+            return valid_strings
+
+        # If no valid strings found, generate the next level
+        next_level: Set[str] = set()
+        for string in level:
+            for i in range(len(string)):
+                # Only try removing parentheses, skip letters
+                if string[i] in "()":
+                    # Create a new string excluding the character at index i
+                    new_string = string[:i] + string[i + 1 :]
+                    next_level.add(new_string)
+
+        # Move to the newly generated level
+        level = next_level
+
+        # Safety check (rare case where level becomes empty)
+        if not level:
+            return [""]
+
+
+def remove_invalid_parentheses_2(s):
+    result: Set[str] = set()
+
+    # Step 1: Determine how many left and right parentheses need to be removed
+    left_to_remove = right_to_remove = 0
+    for char in s:
+        if char == "(":
+            left_to_remove += 1
+        elif char == ")":
+            if left_to_remove > 0:
+                left_to_remove -= 1
+            else:
+                right_to_remove += 1
+
+    # Step 2: Backtracking function
+    def backtrack(index, open_count, close_count, path, left_remain, right_remain):
+        if index == len(s):
+            if left_remain == 0 and right_remain == 0 and open_count == close_count:
+                result.add(path)
+            return
+
+        char = s[index]
+
+        if char == "(":
+            # Option 1: remove the '('
+            if left_remain > 0:
+                backtrack(
+                    index + 1,
+                    open_count,
+                    close_count,
+                    path,
+                    left_remain - 1,
+                    right_remain,
+                )
+            # Option 2: keep the '('
+            backtrack(
+                index + 1,
+                open_count + 1,
+                close_count,
+                path + char,
+                left_remain,
+                right_remain,
+            )
+
+        elif char == ")":
+            # Option 1: remove the ')'
+            if right_remain > 0:
+                backtrack(
+                    index + 1,
+                    open_count,
+                    close_count,
+                    path,
+                    left_remain,
+                    right_remain - 1,
+                )
+            # Option 2: keep the ')' if it balances a previous '('
+            if close_count < open_count:
+                backtrack(
+                    index + 1,
+                    open_count,
+                    close_count + 1,
+                    path + char,
+                    left_remain,
+                    right_remain,
+                )
+
+        else:
+            # Always include non-parenthesis characters
+            backtrack(
+                index + 1,
+                open_count,
+                close_count,
+                path + char,
+                left_remain,
+                right_remain,
+            )
+
+    # Step 3: Start backtracking
+    backtrack(0, 0, 0, "", left_to_remove, right_to_remove)
+    return list(result)