feat(algorithms, backtracking, two-pointers): append chars and combination

Author: BrianLusina

algorithms/backtracking/combination/README.md

@@ -74,3 +74,123 @@ Using 4 different numbers in the range [1,9], the smallest sum we can get is 1+2
 
 - Array
 - Backtracking
+
+## Combination
+
+Given two integers n and k, return all possible combinations of k numbers chosen from the range [1, n].
+
+You may return the answer in any order.
+
+> Note: Combinations are unordered, i.e., [1, 2] and [2, 1] are considered the same combination.
+
+### Examples
+
+Example 1:
+```text
+Input: n = 4, k = 2
+Output: [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]]
+Explanation: There are 4 choose 2 = 6 total combinations.
+Note that combinations are unordered, i.e., [1,2] and [2,1] are considered to be the same combination.
+```
+
+Example 2:
+```text
+Input: n = 1, k = 1
+Output: [[1]]
+Explanation: There is 1 choose 1 = 1 total combination.
+```
+
+### Constraints
+
+- 1 <= n <= 20
+- 1 <= k <= n
+
+### Topics
+
+- Backtracking
+
+### Solutions
+
+#### Variation 1
+
+- Create an empty list `result` to store the final combinations and an empty list `stack` to store the current combination being
+  formed.
+- Define a recursive function `backtrack(start)`, which will generate all possible combinations of size `k` from the
+  numbers starting from `start` up to `n`.
+- In the backtrack function:
+  - If the length of `stack` becomes equal to `k`, it means we have formed a valid combination, so we append a copy of
+    the current comb list to the `result` list. We use `stack[:]` to create a copy of the list since lists are mutable
+    in Python, and we want to preserve the combination at this point without being modified later.
+  - If the length of `stack` is not equal to k, we continue the recursion.
+- Within the `backtrack` function, use a loop to iterate over the numbers starting from `start` up to `n`.
+  - For each number `num` in the range, add it to the current `stack` list to form the combination.
+  - Make a recursive call to `backtrack` with `start` incremented by 1. This ensures that each number can only be used
+    once in each combination, avoiding duplicate combinations.
+  - After the recursive call, remove the last added number from the `stack` list using stack.pop(). This allows us to
+    backtrack and try other numbers for the current position in the combination.
+- Start the recursion by calling `backtrack(1)` with start initially set to 1, as we want to start forming combinations
+  with the numbers from 1 to n.
+- After the recursion is complete, the `result` list will contain all the valid combinations of size `k` formed from the
+  numbers 1 to n. Return `result` as the final result.
+
+The code uses a recursive backtracking approach to generate all the combinations efficiently. It explores all possible
+combinations, avoiding duplicates and forming valid combinations of size k. The result res will contain all such
+combinations at the end.
+
+##### Complexity
+
+###### Time complexity: O(n * k)
+
+`n` is the number of elements and `k` is the size of the subset. The backtrack function is called n times, because there
+are n possible starting points for the subset. For each starting point, the backtrack function iterates through all k
+elements. This is because the `stack` list must contain all k elements in order for it to be a valid subset.
+
+> The time complexity is T(n,k)=O((n/k) * k), as there are(n/k) possible combinations and each requires O(k) work to build
+and copy.
+
+###### Space complexity: O(k)
+
+The `stack` list stores at most k elements. This is because the `backtrack` function only adds elements to the `stack`
+list when the subset is not yet complete.
+
+#### Variation 2
+
+The algorithm uses a backtracking strategy to generate all possible combinations of size k from the range [1…n]. It
+builds each combination step by step, keeping a temporary list path representing the current sequence of chosen numbers.
+At every recursive call, the algorithm selects a new number to add to the path and then continues exploring with the next
+larger number. If the length of the path becomes equal to k, the combination is complete and is added to the result list.
+After exploring one choice, the algorithm backtracks by removing the last number, allowing it to try different alternatives.
+
+To avoid unnecessary work, the recursion stops early whenever the remaining numbers are too few to complete a valid
+combination. This pruning ensures the algorithm explores only those paths that can lead to valid results, making it
+efficient and systematic in covering all unique combinations without repetition.
+
+The steps of the algorithm are as follows:
+
+1. Create an empty list, `ans`, to store all valid combinations.
+2. Define recursive function, `backtrack(path, start)`, where:
+   - `path` stores the current partial combination.
+   - `start` is the smallest number that can be chosen next.
+3. The base case is a complete combination: when `len(path) == k`, save it to ans and return.
+4. Calculate remaining needs:
+   - Compute `need = k - len(path)` (how many more numbers are required).
+   - Compute `max_start = n - need + 1` (the largest possible starting number that still leaves room to complete the
+     combination).
+5. Recursive exploration: For each number `num` from `start` to `max_start`:
+   - Append `num` to `path` (choose).
+   - Call `backtrack(path, num + 1)` (explore further).
+   - Remove `num` from `path` (backtrack/undo choice).
+6. Start recursion by calling `backtrack([], 1)` with an empty path starting from 1.
+7. After recursion finishes, return `ans`, which contains all valid combinations.
+
+##### Complexity
+
+###### Time complexity: O(n * k)
+
+The time complexity is T(n,k)=O((n/k) * k), as there are(n/k) possible combinations and each requires O(k) work to build
+and copy.
+
+###### Space complexity: O(k)
+
+The space complexity is O(k), as the recursion depth can reach k and the path itself holds at most k numbers during
+recursion.

algorithms/backtracking/combination/__init__.py

@@ -1,4 +1,5 @@
 from typing import List
+from itertools import combinations
 
 
 def combination_sum_3(k: int, n: int) -> List[List[int]]:
@@ -20,6 +21,51 @@ def backtrack(num: int, stack: List[int], target: int):
     return result
 
 
+def combine(n: int, k: int) -> List[List[int]]:
+    result = []
+    stack = []
+
+    def backtrack(start: int):
+        if len(stack) == k:
+            result.append(stack[:])
+            return
+
+        for num in range(start, n + 1):
+            stack.append(num)
+            backtrack(num + 1)
+            stack.pop()
+
+    backtrack(1)
+    return result
+
+
+def combine_2(n: int, k: int) -> List[List[int]]:
+    ans = []
+
+    def backtrack(path: List[int], start: int):
+        # If the combination is complete, save it
+        if len(path) == k:
+            ans.append(path[:])
+            return
+
+        # How many more numbers we still need
+        need = k - len(path)
+
+        # Compute the maximum valid starting number
+        # Ensures enough numbers remain to finish the combination
+        max_start = n - need + 1
+
+        # Try each possible next number
+        for num in range(start, max_start + 1):
+            path.append(num)  # choose
+            backtrack(path, num + 1)  # explore
+            path.pop()  # un-choose (backtrack)
+
+    # Start recursion with an empty combination
+    backtrack([], 1)
+    return ans
+
+
 def combination_sum_2(candidates: List[int], target: int) -> List[List[int]]:
     result = []
 

algorithms/backtracking/combination/test_combination.py

@@ -0,0 +1,44 @@
+import unittest
+from typing import List
+from parameterized import parameterized
+from algorithms.backtracking.combination import combine, combine_2
+
+COMBINATION_TEST_CASES = [
+    (1, 1, [[1]]),
+    (2, 2, [[1, 2]]),
+    (3, 3, [[1, 2, 3]]),
+    (3, 1, [[1], [2], [3]]),
+    (4, 2, [[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]),
+    (
+        5,
+        3,
+        [
+            [1, 2, 3],
+            [1, 2, 4],
+            [1, 2, 5],
+            [1, 3, 4],
+            [1, 3, 5],
+            [1, 4, 5],
+            [2, 3, 4],
+            [2, 3, 5],
+            [2, 4, 5],
+            [3, 4, 5],
+        ],
+    ),
+]
+
+
+class CombinationSumTestCase(unittest.TestCase):
+    @parameterized.expand(COMBINATION_TEST_CASES)
+    def test_combination(self, n: int, k: int, expected: List[List[int]]):
+        actual = combine(n, k)
+        self.assertEqual(expected, actual)
+
+    @parameterized.expand(COMBINATION_TEST_CASES)
+    def test_combination_2(self, n: int, k: int, expected: List[List[int]]):
+        actual = combine_2(n, k)
+        self.assertEqual(expected, actual)
+
+
+if __name__ == "__main__":
+    unittest.main()

algorithms/backtracking/combination/test_combination_3.py

@@ -1,29 +1,19 @@
 import unittest
-from . import combination_sum_3
+from typing import List
+from parameterized import parameterized
+from algorithms.backtracking.combination import combination_sum_3
 
+COMBINATION_SUM_3_TEST_CASES = [
+    (3, 7, [[1, 2, 4]]),
+    (3, 9, [[1, 2, 6], [1, 3, 5], [2, 3, 4]]),
+    (4, 1, []),
+    (1, 1, [[1]]),
+]
 
-class CombinationSumTestCase(unittest.TestCase):
-    def test_1(self):
-        """should return [[1,2,4]] for k=3 & n=7"""
-        k = 3
-        n = 7
-        expected = [[1, 2, 4]]
-        actual = combination_sum_3(k, n)
-        self.assertEqual(expected, actual)
 
-    def test_2(self):
-        """should return [[1,2,4]] for k=3 & n=9"""
-        k = 3
-        n = 9
-        expected = [[1, 2, 6], [1, 3, 5], [2, 3, 4]]
-        actual = combination_sum_3(k, n)
-        self.assertEqual(expected, actual)
-
-    def test_3(self):
-        """should return [] for k=4 & n=1"""
-        k = 4
-        n = 1
-        expected = []
+class CombinationSumTestCase(unittest.TestCase):
+    @parameterized.expand(COMBINATION_SUM_3_TEST_CASES)
+    def test_combination_sum_3(self, k: int, n: int, expected: List[List[int]]):
         actual = combination_sum_3(k, n)
         self.assertEqual(expected, actual)
 

algorithms/two_pointers/append_chars_to_make_subsequence/README.md

@@ -0,0 +1,49 @@
+# Append Characters to String to Make Subsequence
+
+You are given two strings s and t consisting of only lowercase English letters.
+
+Return the minimum number of characters that need to be appended to the end of s so that t becomes a subsequence of s.
+
+A subsequence is a string that can be derived from another string by deleting some or no characters without changing the
+order of the remaining characters.
+
+## Examples
+
+
+Example 1:
+
+```text
+Input: s = "coaching", t = "coding"
+Output: 4
+Explanation: Append the characters "ding" to the end of s so that s = "coachingding".
+Now, t is a subsequence of s ("coachingding").
+It can be shown that appending any 3 characters to the end of s will never make t a subsequence.
+```
+
+Example 2:
+
+```text
+Input: s = "abcde", t = "a"
+Output: 0
+Explanation: t is already a subsequence of s ("abcde").
+```
+
+Example 3:
+```text
+Input: s = "z", t = "abcde"
+Output: 5
+Explanation: Append the characters "abcde" to the end of s so that s = "zabcde".
+Now, t is a subsequence of s ("zabcde").
+It can be shown that appending any 4 characters to the end of s will never make t a subsequence.
+```
+ 
+## Constraints
+
+- 1 <= s.length, t.length <= 105
+- `s` and `t` consist only of lowercase English letters.
+
+## Topics
+
+- Two Pointers
+- String
+- Greedy

algorithms/two_pointers/append_chars_to_make_subsequence/__init__.py

@@ -0,0 +1,35 @@
+def append_characters(source: str, target: str) -> int:
+    if source == target:
+        return 0
+
+    target_len = len(target)
+    ptr_target = 0
+
+    for char in source:
+        if ptr_target >= target_len:
+            break
+
+        target_char = target[ptr_target]
+        if char == target_char:
+            ptr_target += 1
+
+    return target_len - ptr_target
+
+
+def append_characters_2(source, target):
+    source_index = 0  # current position in source
+    target_index = 0  # next character index to match in target
+    source_length = len(source)
+    target_length = len(target)
+
+    # Walk through source and try to match target in order
+    while source_index < source_length and target_index < target_length:
+        if source[source_index] == target[target_index]:
+            target_index += (
+                1  # matched target[target_index], move to the next needed char
+            )
+        source_index += 1  # always advance in source
+
+    # target_length - target_index is exactly how many characters remain unmatched in target
+    # and therefore must be appended to source.
+    return target_length - target_index

algorithms/two_pointers/append_chars_to_make_subsequence/test_append_chars_to_make_subsequence.py

@@ -0,0 +1,37 @@
+import unittest
+from parameterized import parameterized
+from algorithms.two_pointers.append_chars_to_make_subsequence import (
+    append_characters,
+    append_characters_2,
+)
+
+APPEND_CHARS_TO_MAKE_SUBSEQUENCE_TEST_CASES = [
+    ("a", "a", 0),
+    ("a", "b", 1),
+    ("z", "zzzz", 3),
+    ("cba", "abc", 2),
+    ("abcde", "ace", 0),
+    ("xyz", "abc", 3),
+    ("axbyc", "abcde", 2),
+    ("ab", "aba", 1),
+    ("abc", "abcbc", 2),
+    ("abcde", "a", 0),
+    ("coaching", "coding", 4),
+    ("z", "abcde", 5),
+]
+
+
+class AppendCharactersTestCase(unittest.TestCase):
+    @parameterized.expand(APPEND_CHARS_TO_MAKE_SUBSEQUENCE_TEST_CASES)
+    def test_append_characters(self, source: str, target: str, expected: int):
+        actual = append_characters(source, target)
+        self.assertEqual(expected, actual)
+
+    @parameterized.expand(APPEND_CHARS_TO_MAKE_SUBSEQUENCE_TEST_CASES)
+    def test_append_characters_2(self, source: str, target: str, expected: int):
+        actual = append_characters_2(source, target)
+        self.assertEqual(expected, actual)
+
+
+if __name__ == "__main__":
+    unittest.main()