feat(algorithms, two-pointers): valid palindrome with one character removal

Author: BrianLusina

algorithms/backtracking/partition_string/__init__.py

@@ -1,5 +1,5 @@
 from typing import List
-from pystrings.palindrome import is_palindrome
+from algorithms.two_pointers.palindrome import is_palindrome
 
 
 def partition(s: str) -> List[List[str]]:

algorithms/greedy/jump_game/README.md

@@ -67,17 +67,17 @@ target remains beyond index 0, then no path exists from the start to the end, an
 
 #### Algorithm
 
-1. We begin by setting the last index of the array as our initial target using the variable target = len(nums) - 1. This 
+1. We begin by setting the last index of the array as our initial target using the variable `target = len(nums) - 1`. This 
     target represents the position we are trying to reach, starting from the end and working backward. By initializing the 
     target this way, we define our goal: to find out if there is any index i from which the target is reachable based on the
     value at that position, nums[i]. This also sets the stage for updating the target if such an index is found.
 
-2. Next, we loop backward through the array using for i in range(len(nums) - 2, -1, -1). Here, i represents the current 
+2. Next, we loop backward through the array using `for i in range(len(nums) - 2, -1, -1)`. Here, `i` represents the current 
    index we are analyzing. At each index i, the value nums[i] tells us how far we can jump forward from that position. 
-   By checking whether i + nums[i] >= target, we determine whether it can reach the current target from index i. This 
+   By checking whether `i + nums[i] >= target`, we determine whether it can reach the current target from index i. This 
    step allows us to use the jump range at each position to decide if it can potentially lead us to the end.
 
-3. If the condition i + nums[i] >= target is TRUE, the current index i can jump far enough to reach the current target. 
+3. If the condition `i + nums[i] >= target` is TRUE, the current index i can jump far enough to reach the current target. 
    In that case, we update target = i, effectively saying, “Now we just need to reach index i instead.” If the condition
    fails, we move back in the array one step further and try again with the previous index. 
    We repeat this process until we either:

pystrings/palindrome/README.md …rithms/two_pointers/palindrome/README.mdpystrings/palindrome/README.md renamed to algorithms/two_pointers/palindrome/README.md pystrings/palindrome/README.md renamed to algorithms/two_pointers/palindrome/README.md

@@ -196,3 +196,82 @@ As only a few variables are used, the space complexity of this solution is O(1).
 - String
 - Dynamic Programming
 - Two Pointers
+
+---
+
+## Valid Palindrome II
+
+Write a function that takes a string as input and checks whether it can be a valid palindrome by removing at most one
+character from it.
+
+### Constraints
+
+- 1 <= `s.length` <= 10^5
+- The string only consists of English letters
+
+### Examples
+
+Example 1:
+
+```text
+Input: s = "aba"
+Output: true
+```
+
+Example 2:
+
+```text
+Input: s = "abca"
+Output: true
+Explanation: You could delete the character 'c'.
+```
+
+Example 3:
+
+```text
+Input: s = "abc"
+Output: false
+```
+
+### Solution
+
+The algorithm uses a two-pointer technique to determine whether a string is a palindrome or can be transformed into it
+by removing at most one character, where one pointer starts at the beginning and the other at the end. As the pointers
+move toward each other, they compare the corresponding characters. If all pairs match, the string is a palindrome.
+However, if a mismatch is detected, the algorithm explores two possibilities: removing the character at either pointer
+and checking if the resulting substring forms a palindrome. If either check passes, the function returns TRUE; otherwise,
+it returns FALSE.
+
+The algorithm consists of two functions:
+
+- `is_substring_palindrome(left, right)`: This helper function checks if a substring of the input string, defined by 
+  `left` and `right` indexes, is a palindrome. It uses a two-pointer approach, comparing characters from both ends
+  inward. If any mismatch is found, it returns FALSE; otherwise, it returns TRUE.
+- `is_valid_palindrome_with_one_char_removal(string)`: This function checks if the entire string is a palindrome or can
+  become one by removing one character. It initializes two pointers, `left_pointer` at the start and `right_pointer` at 
+  end of the string:
+  - If the characters at the `left_pointer` and `right_pointer` are the same, it moves both pointers inward.
+  - If the characters differ, it checks two cases by calling is_substring_palindrome:
+    - The substring from `left_pointer + 1` to `right_pointer`
+    - The substring from `left_pointer` to `right_pointer - 1`
+  - If either case returns TRUE, the function returns TRUE; otherwise, it returns FALSE. 
+
+If the traversal completes without finding a mismatch, the string is a palindrome, and the function returns TRUE.
+
+![Solution 1](./images/solutions/is_valid_palindrome_with_one_char_removal_solution_1.png)
+![Solution 2](./images/solutions/is_valid_palindrome_with_one_char_removal_solution_2.png)
+![Solution 3](./images/solutions/is_valid_palindrome_with_one_char_removal_solution_3.png)
+![Solution 4](./images/solutions/is_valid_palindrome_with_one_char_removal_solution_4.png)
+![Solution 5](./images/solutions/is_valid_palindrome_with_one_char_removal_solution_5.png)
+![Solution 6](./images/solutions/is_valid_palindrome_with_one_char_removal_solution_6.png)
+![Solution 7](./images/solutions/is_valid_palindrome_with_one_char_removal_solution_7.png)
+![Solution 8](./images/solutions/is_valid_palindrome_with_one_char_removal_solution_8.png)
+![Solution 9](./images/solutions/is_valid_palindrome_with_one_char_removal_solution_9.png)
+
+#### Time Complexity
+
+The time complexity of the solution above is O(n), where n is the length of the string
+
+#### Space Complexity
+
+The space complexity of solution above is O(1).

pystrings/palindrome/__init__.py …thms/two_pointers/palindrome/__init__.pypystrings/palindrome/__init__.py renamed to algorithms/two_pointers/palindrome/__init__.py pystrings/palindrome/__init__.py renamed to algorithms/two_pointers/palindrome/__init__.py

@@ -162,3 +162,45 @@ def is_palindrome_number_2(x: int) -> bool:
         left += 1
         right -= 1
     return True
+
+
+def is_valid_palindrome_with_one_char_removal(s: str) -> bool:
+    """
+    Checks if a string s can become a valid palindrome with at most one character removal. Returns True if it can, False
+    otherwise
+    Args:
+        s (str): string to check
+    Returns:
+        bool: True if after removal of at most one character, the string becomes a valid palindrome, otherwise False
+    """
+    left_pointer = 0
+    right_pointer = len(s) - 1
+
+    def is_substring_palindrome(left: int, right: int) -> bool:
+        """
+        Checks if a given substring is a valid palindrome
+        Args:
+            left(int): the left index on the string to check
+            right(int): the right index on the string to check
+        Returns:
+            bool: True if the substring is a valid palindrome, else False
+        """
+        while left < right:
+            if s[left] != s[right]:
+                return False
+            left += 1
+            right -= 1
+        return True
+
+    while left_pointer < right_pointer:
+        if s[left_pointer] != s[right_pointer]:
+            # validate that the substrings are valid palindromes
+            return is_substring_palindrome(
+                left_pointer + 1, right_pointer
+            ) or is_substring_palindrome(left_pointer, right_pointer - 1)
+
+        # move the pointers as the characters are equal
+        left_pointer += 1
+        right_pointer -= 1
+
+    return True