feat(algorithms, dynamic-programming): max sub array

Author: BrianLusina

…structures/arrays/max_subarray/README.md …namic_programming/max_subarray/README.mddatastructures/arrays/max_subarray/README.md renamed to algorithms/dynamic_programming/max_subarray/README.md datastructures/arrays/max_subarray/README.md renamed to algorithms/dynamic_programming/max_subarray/README.md

@@ -46,3 +46,17 @@ def find_max_sub_array(array: List[int]) -> int:
             max_ending = 0
 
     return max_so_far
+
+
+def max_sub_array(nums: List[int]) -> int:
+    if not nums:
+        return 0
+
+    max_sum = current_sum = nums[0]
+
+    for num in nums[1:]:
+        current_sum = max(current_sum, 0) + num
+
+        max_sum = max(max_sum, current_sum)
+
+    return max_sum

…ructures/arrays/max_subarray/__init__.py …mic_programming/max_subarray/__init__.pydatastructures/arrays/max_subarray/__init__.py renamed to algorithms/dynamic_programming/max_subarray/__init__.py datastructures/arrays/max_subarray/__init__.py renamed to algorithms/dynamic_programming/max_subarray/__init__.py

@@ -48,8 +48,3 @@ def find_sub_arr_maxsum(array):
             maximum = 0
 
     return sub_array_dict
-
-
-if __name__ == "__main__":
-    arr = [4, -1, 2, 1, -40, 1, 2, -1, 4]
-    print(f"Sub arrays for {arr} are {find_sub_arr_maxsum(arr)}")

…/arrays/max_subarray/sub_array_maxsum.py …ramming/max_subarray/sub_array_maxsum.pydatastructures/arrays/max_subarray/sub_array_maxsum.py renamed to algorithms/dynamic_programming/max_subarray/sub_array_maxsum.py datastructures/arrays/max_subarray/sub_array_maxsum.py renamed to algorithms/dynamic_programming/max_subarray/sub_array_maxsum.py

@@ -0,0 +1,35 @@
+import unittest
+from typing import List
+from parameterized import parameterized
+from algorithms.dynamic_programming.max_subarray import (
+    find_max_sub_array,
+    max_sub_array,
+)
+
+
+MAX_SUB_ARRAY_TEST_CASES = [
+    ([], 0),
+    ([1], 1),
+    ([-2, 1, -3, 4, -1, 2, 1, -5, 4], 6),
+    ([5, 4, -1, 7, 8], 23),
+    ([1, 2, 3, 4, -10], 10),
+    ([-2, 1, -3, 4, 1, -1, 2, 1, -3, 4, -2, -5], 8),
+    ([-10, 2, 9, 4, -6, -3, 1, 2, 4, -3, 6], 16),
+    ([-3, -2, -8, -7, -6, -4, -6, -3], -2),
+]
+
+
+class MaxSubArrayTestCases(unittest.TestCase):
+    @parameterized.expand(MAX_SUB_ARRAY_TEST_CASES)
+    def test_find_max_sub_array(self, nums: List[int], expected: int):
+        actual = find_max_sub_array(nums)
+        self.assertEqual(expected, actual)
+
+    @parameterized.expand(MAX_SUB_ARRAY_TEST_CASES)
+    def test_max_sub_array(self, nums: List[int], expected: int):
+        actual = max_sub_array(nums)
+        self.assertEqual(expected, actual)
+
+
+if __name__ == "__main__":
+    unittest.main()

algorithms/dynamic_programming/max_subarray/test_max_subarray.py

@@ -1,6 +1,7 @@
 from typing import Dict, Tuple
 from functools import lru_cache
 
+
 def unique_paths_math(m: int, n: int) -> int:
     """Uses math formula"""
     ans = 1
@@ -73,6 +74,6 @@ def unique_paths_bottom_up(rows: int, cols: int) -> int:
     # Fill in the rest of the table
     for i in range(1, rows):
         for j in range(1, cols):
-            dp[i][j] = dp[i-1][j] + dp[i][j-1]
+            dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
 
-    return dp[rows-1][cols-1]
+    return dp[rows - 1][cols - 1]

algorithms/dynamic_programming/unique_paths/__init__.py

@@ -0,0 +1,34 @@
+# Create Maximum Number
+
+You are given two integer arrays, nums1 and nums2, of lengths m and n, respectively. Each array represents the digits of
+a number.
+
+You are also given an integer k. Create the largest possible number of length k (where k ≤ m + n) using digits from both
+arrays. You may interleave digits from the two arrays, but the relative order of digits within the same array must be preserved.
+
+Return an array of k digits representing the maximum number.
+
+## Constraints
+
+- `m` = `nums1.length`
+- `n` = `nums2.length`
+- 1 < `m`, `n` <= 500
+- 0 <= `nums[i]`, `nums2[i]` <= 9
+- 1 <= `k` <= `m` + `n`
+- `nums1` and `nums2` do not have leading zeros
+
+## Examples
+
+![Example 1](./images/examples/create_maximum_number_example_1.png)
+![Example 2](./images/examples/create_maximum_number_example_2.png)
+![Example 3](./images/examples/create_maximum_number_example_3.png)
+![Example 4](./images/examples/create_maximum_number_example_4.png)
+![Example 5](./images/examples/create_maximum_number_example_5.png)
+
+## Topics
+
+- Array
+- Two Pointers
+- Stack
+- Greedy
+- Monotonic Stack

algorithms/greedy/create_maximum_number/README.md

@@ -0,0 +1,110 @@
+from typing import List
+
+
+def max_number(nums1: List[int], nums2: List[int], k: int) -> List[int]:
+    """
+    Creates Maximum number from two arrays nums1 and nums2 where the number has to be of length k using digits from both
+    integer arrays
+    Args:
+        nums1(int): first integer array
+        nums2(int): second integer array
+        k(int): number of digits of final array
+    Returns:
+        list: list of integers formed from integer array
+    """
+
+    def extract_maximum_subsequence(nums: List[int], l: int):
+        """
+        Extracts maximum subsequence from nums of length l using a monotonic stack approach
+        Args:
+            nums(list): list of integers
+            l(int): length of extracted maximum subsequence
+        Returns:
+
+        """
+        n = len(nums)
+        stack = [0] * l  # Pre-allocate stack of size k
+        top = -1  # Stack pointer (top index)
+        elements_to_drop = n - l  # Number of elements we can skip
+
+        for num in nums:
+            # Pop smaller elements from stack if we can still drop elements
+            while top >= 0 and stack[top] < num and elements_to_drop > 0:
+                top -= 1
+                elements_to_drop -= 1
+
+            # Add current element if stack not full
+            if top + 1 < l:
+                top += 1
+                stack[top] = num
+            else:
+                # Stack is full, just decrement elements_to_drop
+                elements_to_drop -= 1
+
+        return stack
+
+    def is_greater(nums_one, nums_two, idx1: int, idx2: int) -> bool:
+        """
+        Compare two arrays starting from given indices.
+        Returns True if nums1[idx1:] is lexicographically greater than nums2[idx2:].
+        """
+        # If nums1 exhausted, it's not greater
+        if idx1 >= len(nums_one):
+            return False
+        # If nums2 exhausted but nums1 has elements, nums1 is greater
+        if idx2 >= len(nums_two):
+            return True
+        # Compare current elements
+        if nums_one[idx1] > nums_two[idx2]:
+            return True
+        if nums_one[idx1] < nums_two[idx2]:
+            return False
+        # If equal, recursively compare next elements
+        return is_greater(nums_one, nums_two, idx1 + 1, idx2 + 1)
+
+    def merge_arrays(
+        nums_1_subsequence: List[int], nums_2_subsequence: List[int]
+    ) -> List[int]:
+        """
+        Merge two arrays to create the maximum possible array.
+        Always picks the lexicographically larger remaining portion.
+        """
+        nums_1_len, nums_2_len = len(nums_1_subsequence), len(nums_2_subsequence)
+        idx1 = idx2 = 0
+        result = [0] * (nums_1_len + nums_2_len)
+
+        for pos in range(nums_1_len + nums_2_len):
+            # Choose from nums1 if it has greater or equal remaining portion
+            if is_greater(nums_1_subsequence, nums_2_subsequence, idx1, idx2):
+                result[pos] = nums_1_subsequence[idx1]
+                idx1 += 1
+            else:
+                result[pos] = nums_2_subsequence[idx2]
+                idx2 += 1
+
+        return result
+
+    # Main logic
+    m, n = len(nums1), len(nums2)
+    # Determine valid range for elements to take from nums1
+    min_from_nums1 = max(0, k - n)  # Must take at least k-n from nums1
+    max_from_nums1 = min(k, m)  # Can take at most min(k, m) from nums1
+
+    max_result = [0] * k
+
+    # Try all valid splits between nums1 and nums2
+    for take_from_nums1 in range(min_from_nums1, max_from_nums1 + 1):
+        take_from_nums2 = k - take_from_nums1
+
+        # Get maximum subsequences from each array
+        subsequence1 = extract_maximum_subsequence(nums1, take_from_nums1)
+        subsequence2 = extract_maximum_subsequence(nums2, take_from_nums2)
+
+        # Merge the subsequences to get candidate result
+        candidate = merge_arrays(subsequence1, subsequence2)
+
+        # Update max_result if candidate is lexicographically larger
+        if max_result < candidate:
+            max_result = candidate
+
+    return max_result