Consolidate duplicate implementations of max subarray

DIRECTORY.md

@@ -293,7 +293,7 @@
  * [Inversions](divide_and_conquer/inversions.py)
  * [Kth Order Statistic](divide_and_conquer/kth_order_statistic.py)
  * [Max Difference Pair](divide_and_conquer/max_difference_pair.py)
- * [Max Subarray Sum](divide_and_conquer/max_subarray_sum.py)
+ * [Max Subarray](divide_and_conquer/max_subarray.py)
  * [Mergesort](divide_and_conquer/mergesort.py)
  * [Peak](divide_and_conquer/peak.py)
  * [Power](divide_and_conquer/power.py)
@@ -324,8 +324,7 @@
  * [Matrix Chain Order](dynamic_programming/matrix_chain_order.py)
  * [Max Non Adjacent Sum](dynamic_programming/max_non_adjacent_sum.py)
  * [Max Product Subarray](dynamic_programming/max_product_subarray.py)
- * [Max Sub Array](dynamic_programming/max_sub_array.py)
- * [Max Sum Contiguous Subsequence](dynamic_programming/max_sum_contiguous_subsequence.py)
+ * [Max Subarray Sum](dynamic_programming/max_subarray_sum.py)
  * [Min Distance Up Bottom](dynamic_programming/min_distance_up_bottom.py)
  * [Minimum Coin Change](dynamic_programming/minimum_coin_change.py)
  * [Minimum Cost Path](dynamic_programming/minimum_cost_path.py)
@@ -591,12 +590,10 @@
  * [Is Square Free](maths/is_square_free.py)
  * [Jaccard Similarity](maths/jaccard_similarity.py)
  * [Juggler Sequence](maths/juggler_sequence.py)
- * [Kadanes](maths/kadanes.py)
  * [Karatsuba](maths/karatsuba.py)
  * [Krishnamurthy Number](maths/krishnamurthy_number.py)
  * [Kth Lexicographic Permutation](maths/kth_lexicographic_permutation.py)
  * [Largest Of Very Large Numbers](maths/largest_of_very_large_numbers.py)
- * [Largest Subarray Sum](maths/largest_subarray_sum.py)
  * [Least Common Multiple](maths/least_common_multiple.py)
  * [Line Length](maths/line_length.py)
  * [Liouville Lambda](maths/liouville_lambda.py)
@@ -733,7 +730,6 @@
  * [Linear Congruential Generator](other/linear_congruential_generator.py)
  * [Lru Cache](other/lru_cache.py)
  * [Magicdiamondpattern](other/magicdiamondpattern.py)
- * [Maximum Subarray](other/maximum_subarray.py)
  * [Maximum Subsequence](other/maximum_subsequence.py)
  * [Nested Brackets](other/nested_brackets.py)
  * [Number Container System](other/number_container_system.py)

divide_and_conquer/max_subarray.py

@@ -0,0 +1,112 @@
+"""
+The maximum subarray problem is the task of finding the continuous subarray that has the
+maximum sum within a given array of numbers. For example, given the array
+[-2, 1, -3, 4, -1, 2, 1, -5, 4], the contiguous subarray with the maximum sum is
+[4, -1, 2, 1], which has a sum of 6.
+
+This divide-and-conquer algorithm finds the maximum subarray in O(n log n) time.
+"""
+from __future__ import annotations
+
+import time
+from collections.abc import Sequence
+from random import randint
+
+from matplotlib import pyplot as plt
+
+
+def max_subarray(
+ arr: Sequence[float], low: int, high: int
+) -> tuple[int | None, int | None, float]:
+ """
+ Solves the maximum subarray problem using divide and conquer.
+ :param arr: the given array of numbers
+ :param low: the start index
+ :param high: the end index
+ :return: the start index of the maximum subarray, the end index of the
+ maximum subarray, and the maximum subarray sum
+
+ >>> nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (3, 6, 6)
+ >>> nums = [2, 8, 9]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (0, 2, 19)
+ >>> nums = [0, 0]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (0, 0, 0)
+ >>> nums = [-1.0, 0.0, 1.0]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (2, 2, 1.0)
+ >>> nums = [-2, -3, -1, -4, -6]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (2, 2, -1)
+ >>> max_subarray([], 0, 0)
+ (None, None, 0)
+ """
+ if not arr:
+ return None, None, 0
+ if low == high:
+ return low, high, arr[low]
+
+ mid = (low + high) // 2
+ left_low, left_high, left_sum = max_subarray(arr, low, mid)
+ right_low, right_high, right_sum = max_subarray(arr, mid + 1, high)
+ cross_left, cross_right, cross_sum = max_cross_sum(arr, low, mid, high)
+ if left_sum >= right_sum and left_sum >= cross_sum:
+ return left_low, left_high, left_sum
+ elif right_sum >= left_sum and right_sum >= cross_sum:
+ return right_low, right_high, right_sum
+ return cross_left, cross_right, cross_sum
+
+
+def max_cross_sum(
+ arr: Sequence[float], low: int, mid: int, high: int
+) -> tuple[int, int, float]:
+ left_sum, max_left = float("-inf"), -1
+ right_sum, max_right = float("-inf"), -1
+
+ summ: int | float = 0
+ for i in range(mid, low - 1, -1):
+ summ += arr[i]
+ if summ > left_sum:
+ left_sum = summ
+ max_left = i
+
+ summ = 0
+ for i in range(mid + 1, high + 1):
+ summ += arr[i]
+ if summ > right_sum:
+ right_sum = summ
+ max_right = i
+
+ return max_left, max_right, (left_sum + right_sum)
+
+
+def time_max_subarray(input_size: int) -> float:
+ arr = [randint(1, input_size) for _ in range(input_size)]
+ start = time.time()
+ max_subarray(arr, 0, input_size - 1)
+ end = time.time()
+ return end - start
+
+
+def plot_runtimes() -> None:
+ input_sizes = [10, 100, 1000, 10000, 50000, 100000, 200000, 300000, 400000, 500000]
+ runtimes = [time_max_subarray(input_size) for input_size in input_sizes]
+ print("No of Inputs\t\tTime Taken")
+ for input_size, runtime in zip(input_sizes, runtimes):
+ print(input_size, "\t\t", runtime)
+ plt.plot(input_sizes, runtimes)
+ plt.xlabel("Number of Inputs")
+ plt.ylabel("Time taken in seconds")
+ plt.show()
+
+
+if __name__ == "__main__":
+ """
+ A random simulation of this algorithm.
+ """
+ from doctest import testmod
+
+ testmod()

dynamic_programming/max_subarray_sum.py

@@ -0,0 +1,60 @@
+"""
+The maximum subarray sum problem is the task of finding the maximum sum that can be
+obtained from a contiguous subarray within a given array of numbers. For example, given
+the array [-2, 1, -3, 4, -1, 2, 1, -5, 4], the contiguous subarray with the maximum sum
+is [4, -1, 2, 1], so the maximum subarray sum is 6.
+
+Kadane's algorithm is a simple dynamic programming algorithm that solves the maximum
+subarray sum problem in O(n) time and O(1) space.
+
+Reference: https://en.wikipedia.org/wiki/Maximum_subarray_problem
+"""
+from collections.abc import Sequence
+
+
+def max_subarray_sum(
+ arr: Sequence[float], allow_empty_subarrays: bool = False
+) -> float:
+ """
+ Solves the maximum subarray sum problem using Kadane's algorithm.
+ :param arr: the given array of numbers
+ :param allow_empty_subarrays: if True, then the algorithm considers empty subarrays
+
+ >>> max_subarray_sum([2, 8, 9])
+ 19
+ >>> max_subarray_sum([0, 0])
+ 0
+ >>> max_subarray_sum([-1.0, 0.0, 1.0])
+ 1.0
+ >>> max_subarray_sum([1, 2, 3, 4, -2])
+ 10
+ >>> max_subarray_sum([-2, 1, -3, 4, -1, 2, 1, -5, 4])
+ 6
+ >>> max_subarray_sum([2, 3, -9, 8, -2])
+ 8
+ >>> max_subarray_sum([-2, -3, -1, -4, -6])
+ -1
+ >>> max_subarray_sum([-2, -3, -1, -4, -6], allow_empty_subarrays=True)
+ 0
+ >>> max_subarray_sum([])
+ 0
+ """
+ if not arr:
+ return 0
+
+ max_sum = 0 if allow_empty_subarrays else float("-inf")
+ curr_sum = 0.0
+ for num in arr:
+ curr_sum = max(0 if allow_empty_subarrays else num, curr_sum + num)
+ max_sum = max(max_sum, curr_sum)
+
+ return max_sum
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod()
+
+ nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+ print(f"{max_subarray_sum(nums) = }")

DIRECTORY.md

@@ -293,7 +293,7 @@
  * [Inversions](divide_and_conquer/inversions.py)
  * [Kth Order Statistic](divide_and_conquer/kth_order_statistic.py)
  * [Max Difference Pair](divide_and_conquer/max_difference_pair.py)
- * [Max Subarray Sum](divide_and_conquer/max_subarray_sum.py)
+ * [Max Subarray](divide_and_conquer/max_subarray.py)
  * [Mergesort](divide_and_conquer/mergesort.py)
  * [Peak](divide_and_conquer/peak.py)
  * [Power](divide_and_conquer/power.py)
@@ -324,8 +324,7 @@
  * [Matrix Chain Order](dynamic_programming/matrix_chain_order.py)
  * [Max Non Adjacent Sum](dynamic_programming/max_non_adjacent_sum.py)
  * [Max Product Subarray](dynamic_programming/max_product_subarray.py)
- * [Max Sub Array](dynamic_programming/max_sub_array.py)
- * [Max Sum Contiguous Subsequence](dynamic_programming/max_sum_contiguous_subsequence.py)
+ * [Max Subarray Sum](dynamic_programming/max_subarray_sum.py)
  * [Min Distance Up Bottom](dynamic_programming/min_distance_up_bottom.py)
  * [Minimum Coin Change](dynamic_programming/minimum_coin_change.py)
  * [Minimum Cost Path](dynamic_programming/minimum_cost_path.py)
@@ -591,12 +590,10 @@
  * [Is Square Free](maths/is_square_free.py)
  * [Jaccard Similarity](maths/jaccard_similarity.py)
  * [Juggler Sequence](maths/juggler_sequence.py)
- * [Kadanes](maths/kadanes.py)
  * [Karatsuba](maths/karatsuba.py)
  * [Krishnamurthy Number](maths/krishnamurthy_number.py)
  * [Kth Lexicographic Permutation](maths/kth_lexicographic_permutation.py)
  * [Largest Of Very Large Numbers](maths/largest_of_very_large_numbers.py)
- * [Largest Subarray Sum](maths/largest_subarray_sum.py)
  * [Least Common Multiple](maths/least_common_multiple.py)
  * [Line Length](maths/line_length.py)
  * [Liouville Lambda](maths/liouville_lambda.py)
@@ -733,7 +730,6 @@
  * [Linear Congruential Generator](other/linear_congruential_generator.py)
  * [Lru Cache](other/lru_cache.py)
  * [Magicdiamondpattern](other/magicdiamondpattern.py)
- * [Maximum Subarray](other/maximum_subarray.py)
  * [Maximum Subsequence](other/maximum_subsequence.py)
  * [Nested Brackets](other/nested_brackets.py)
  * [Number Container System](other/number_container_system.py)

divide_and_conquer/max_subarray.py

@@ -0,0 +1,112 @@
+"""
+The maximum subarray problem is the task of finding the continuous subarray that has the
+maximum sum within a given array of numbers. For example, given the array
+[-2, 1, -3, 4, -1, 2, 1, -5, 4], the contiguous subarray with the maximum sum is
+[4, -1, 2, 1], which has a sum of 6.
+
+This divide-and-conquer algorithm finds the maximum subarray in O(n log n) time.
+"""
+from __future__ import annotations
+
+import time
+from collections.abc import Sequence
+from random import randint
+
+from matplotlib import pyplot as plt
+
+
+def max_subarray(
+ arr: Sequence[float], low: int, high: int
+) -> tuple[int | None, int | None, float]:
+ """
+ Solves the maximum subarray problem using divide and conquer.
+ :param arr: the given array of numbers
+ :param low: the start index
+ :param high: the end index
+ :return: the start index of the maximum subarray, the end index of the
+ maximum subarray, and the maximum subarray sum
+
+ >>> nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (3, 6, 6)
+ >>> nums = [2, 8, 9]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (0, 2, 19)
+ >>> nums = [0, 0]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (0, 0, 0)
+ >>> nums = [-1.0, 0.0, 1.0]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (2, 2, 1.0)
+ >>> nums = [-2, -3, -1, -4, -6]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (2, 2, -1)
+ >>> max_subarray([], 0, 0)
+ (None, None, 0)
+ """
+ if not arr:
+ return None, None, 0
+ if low == high:
+ return low, high, arr[low]
+
+ mid = (low + high) // 2
+ left_low, left_high, left_sum = max_subarray(arr, low, mid)
+ right_low, right_high, right_sum = max_subarray(arr, mid + 1, high)
+ cross_left, cross_right, cross_sum = max_cross_sum(arr, low, mid, high)
+ if left_sum >= right_sum and left_sum >= cross_sum:
+ return left_low, left_high, left_sum
+ elif right_sum >= left_sum and right_sum >= cross_sum:
+ return right_low, right_high, right_sum
+ return cross_left, cross_right, cross_sum
+
+
+def max_cross_sum(
+ arr: Sequence[float], low: int, mid: int, high: int
+) -> tuple[int, int, float]:
+ left_sum, max_left = float("-inf"), -1
+ right_sum, max_right = float("-inf"), -1
+
+ summ: int | float = 0
+ for i in range(mid, low - 1, -1):
+ summ += arr[i]
+ if summ > left_sum:
+ left_sum = summ
+ max_left = i
+
+ summ = 0
+ for i in range(mid + 1, high + 1):
+ summ += arr[i]
+ if summ > right_sum:
+ right_sum = summ
+ max_right = i
+
+ return max_left, max_right, (left_sum + right_sum)
+
+
+def time_max_subarray(input_size: int) -> float:
+ arr = [randint(1, input_size) for _ in range(input_size)]
+ start = time.time()
+ max_subarray(arr, 0, input_size - 1)
+ end = time.time()
+ return end - start
+
+
+def plot_runtimes() -> None:
+ input_sizes = [10, 100, 1000, 10000, 50000, 100000, 200000, 300000, 400000, 500000]
+ runtimes = [time_max_subarray(input_size) for input_size in input_sizes]
+ print("No of Inputs\t\tTime Taken")
+ for input_size, runtime in zip(input_sizes, runtimes):
+ print(input_size, "\t\t", runtime)
+ plt.plot(input_sizes, runtimes)
+ plt.xlabel("Number of Inputs")
+ plt.ylabel("Time taken in seconds")
+ plt.show()
+
+
+if __name__ == "__main__":
+ """
+ A random simulation of this algorithm.
+ """
+ from doctest import testmod
+
+ testmod()

dynamic_programming/max_subarray_sum.py

@@ -0,0 +1,60 @@
+"""
+The maximum subarray sum problem is the task of finding the maximum sum that can be
+obtained from a contiguous subarray within a given array of numbers. For example, given
+the array [-2, 1, -3, 4, -1, 2, 1, -5, 4], the contiguous subarray with the maximum sum
+is [4, -1, 2, 1], so the maximum subarray sum is 6.
+
+Kadane's algorithm is a simple dynamic programming algorithm that solves the maximum
+subarray sum problem in O(n) time and O(1) space.
+
+Reference: https://en.wikipedia.org/wiki/Maximum_subarray_problem
+"""
+from collections.abc import Sequence
+
+
+def max_subarray_sum(
+ arr: Sequence[float], allow_empty_subarrays: bool = False
+) -> float:
+ """
+ Solves the maximum subarray sum problem using Kadane's algorithm.
+ :param arr: the given array of numbers
+ :param allow_empty_subarrays: if True, then the algorithm considers empty subarrays
+
+ >>> max_subarray_sum([2, 8, 9])
+ 19
+ >>> max_subarray_sum([0, 0])
+ 0
+ >>> max_subarray_sum([-1.0, 0.0, 1.0])
+ 1.0
+ >>> max_subarray_sum([1, 2, 3, 4, -2])
+ 10
+ >>> max_subarray_sum([-2, 1, -3, 4, -1, 2, 1, -5, 4])
+ 6
+ >>> max_subarray_sum([2, 3, -9, 8, -2])
+ 8
+ >>> max_subarray_sum([-2, -3, -1, -4, -6])
+ -1
+ >>> max_subarray_sum([-2, -3, -1, -4, -6], allow_empty_subarrays=True)
+ 0
+ >>> max_subarray_sum([])
+ 0
+ """
+ if not arr:
+ return 0
+
+ max_sum = 0 if allow_empty_subarrays else float("-inf")
+ curr_sum = 0.0
+ for num in arr:
+ curr_sum = max(0 if allow_empty_subarrays else num, curr_sum + num)
+ max_sum = max(max_sum, curr_sum)
+
+ return max_sum
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod()
+
+ nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+ print(f"{max_subarray_sum(nums) = }")

DIRECTORY.md

@@ -293,7 +293,7 @@
  * [Inversions](divide_and_conquer/inversions.py)
  * [Kth Order Statistic](divide_and_conquer/kth_order_statistic.py)
  * [Max Difference Pair](divide_and_conquer/max_difference_pair.py)
- * [Max Subarray Sum](divide_and_conquer/max_subarray_sum.py)
+ * [Max Subarray](divide_and_conquer/max_subarray.py)
  * [Mergesort](divide_and_conquer/mergesort.py)
  * [Peak](divide_and_conquer/peak.py)
  * [Power](divide_and_conquer/power.py)
@@ -324,8 +324,7 @@
  * [Matrix Chain Order](dynamic_programming/matrix_chain_order.py)
  * [Max Non Adjacent Sum](dynamic_programming/max_non_adjacent_sum.py)
  * [Max Product Subarray](dynamic_programming/max_product_subarray.py)
- * [Max Sub Array](dynamic_programming/max_sub_array.py)
- * [Max Sum Contiguous Subsequence](dynamic_programming/max_sum_contiguous_subsequence.py)
+ * [Max Subarray Sum](dynamic_programming/max_subarray_sum.py)
  * [Min Distance Up Bottom](dynamic_programming/min_distance_up_bottom.py)
  * [Minimum Coin Change](dynamic_programming/minimum_coin_change.py)
  * [Minimum Cost Path](dynamic_programming/minimum_cost_path.py)
@@ -591,12 +590,10 @@
  * [Is Square Free](maths/is_square_free.py)
  * [Jaccard Similarity](maths/jaccard_similarity.py)
  * [Juggler Sequence](maths/juggler_sequence.py)
- * [Kadanes](maths/kadanes.py)
  * [Karatsuba](maths/karatsuba.py)
  * [Krishnamurthy Number](maths/krishnamurthy_number.py)
  * [Kth Lexicographic Permutation](maths/kth_lexicographic_permutation.py)
  * [Largest Of Very Large Numbers](maths/largest_of_very_large_numbers.py)
- * [Largest Subarray Sum](maths/largest_subarray_sum.py)
  * [Least Common Multiple](maths/least_common_multiple.py)
  * [Line Length](maths/line_length.py)
  * [Liouville Lambda](maths/liouville_lambda.py)
@@ -733,7 +730,6 @@
  * [Linear Congruential Generator](other/linear_congruential_generator.py)
  * [Lru Cache](other/lru_cache.py)
  * [Magicdiamondpattern](other/magicdiamondpattern.py)
- * [Maximum Subarray](other/maximum_subarray.py)
  * [Maximum Subsequence](other/maximum_subsequence.py)
  * [Nested Brackets](other/nested_brackets.py)
  * [Number Container System](other/number_container_system.py)

divide_and_conquer/max_subarray.py

@@ -0,0 +1,112 @@
+"""
+The maximum subarray problem is the task of finding the continuous subarray that has the
+maximum sum within a given array of numbers. For example, given the array
+[-2, 1, -3, 4, -1, 2, 1, -5, 4], the contiguous subarray with the maximum sum is
+[4, -1, 2, 1], which has a sum of 6.
+
+This divide-and-conquer algorithm finds the maximum subarray in O(n log n) time.
+"""
+from __future__ import annotations
+
+import time
+from collections.abc import Sequence
+from random import randint
+
+from matplotlib import pyplot as plt
+
+
+def max_subarray(
+ arr: Sequence[float], low: int, high: int
+) -> tuple[int | None, int | None, float]:
+ """
+ Solves the maximum subarray problem using divide and conquer.
+ :param arr: the given array of numbers
+ :param low: the start index
+ :param high: the end index
+ :return: the start index of the maximum subarray, the end index of the
+ maximum subarray, and the maximum subarray sum
+
+ >>> nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (3, 6, 6)
+ >>> nums = [2, 8, 9]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (0, 2, 19)
+ >>> nums = [0, 0]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (0, 0, 0)
+ >>> nums = [-1.0, 0.0, 1.0]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (2, 2, 1.0)
+ >>> nums = [-2, -3, -1, -4, -6]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (2, 2, -1)
+ >>> max_subarray([], 0, 0)
+ (None, None, 0)
+ """
+ if not arr:
+ return None, None, 0
+ if low == high:
+ return low, high, arr[low]
+
+ mid = (low + high) // 2
+ left_low, left_high, left_sum = max_subarray(arr, low, mid)
+ right_low, right_high, right_sum = max_subarray(arr, mid + 1, high)
+ cross_left, cross_right, cross_sum = max_cross_sum(arr, low, mid, high)
+ if left_sum >= right_sum and left_sum >= cross_sum:
+ return left_low, left_high, left_sum
+ elif right_sum >= left_sum and right_sum >= cross_sum:
+ return right_low, right_high, right_sum
+ return cross_left, cross_right, cross_sum
+
+
+def max_cross_sum(
+ arr: Sequence[float], low: int, mid: int, high: int
+) -> tuple[int, int, float]:
+ left_sum, max_left = float("-inf"), -1
+ right_sum, max_right = float("-inf"), -1
+
+ summ: int | float = 0
+ for i in range(mid, low - 1, -1):
+ summ += arr[i]
+ if summ > left_sum:
+ left_sum = summ
+ max_left = i
+
+ summ = 0
+ for i in range(mid + 1, high + 1):
+ summ += arr[i]
+ if summ > right_sum:
+ right_sum = summ
+ max_right = i
+
+ return max_left, max_right, (left_sum + right_sum)
+
+
+def time_max_subarray(input_size: int) -> float:
+ arr = [randint(1, input_size) for _ in range(input_size)]
+ start = time.time()
+ max_subarray(arr, 0, input_size - 1)
+ end = time.time()
+ return end - start
+
+
+def plot_runtimes() -> None:
+ input_sizes = [10, 100, 1000, 10000, 50000, 100000, 200000, 300000, 400000, 500000]
+ runtimes = [time_max_subarray(input_size) for input_size in input_sizes]
+ print("No of Inputs\t\tTime Taken")
+ for input_size, runtime in zip(input_sizes, runtimes):
+ print(input_size, "\t\t", runtime)
+ plt.plot(input_sizes, runtimes)
+ plt.xlabel("Number of Inputs")
+ plt.ylabel("Time taken in seconds")
+ plt.show()
+
+
+if __name__ == "__main__":
+ """
+ A random simulation of this algorithm.
+ """
+ from doctest import testmod
+
+ testmod()

dynamic_programming/max_subarray_sum.py

@@ -0,0 +1,60 @@
+"""
+The maximum subarray sum problem is the task of finding the maximum sum that can be
+obtained from a contiguous subarray within a given array of numbers. For example, given
+the array [-2, 1, -3, 4, -1, 2, 1, -5, 4], the contiguous subarray with the maximum sum
+is [4, -1, 2, 1], so the maximum subarray sum is 6.
+
+Kadane's algorithm is a simple dynamic programming algorithm that solves the maximum
+subarray sum problem in O(n) time and O(1) space.
+
+Reference: https://en.wikipedia.org/wiki/Maximum_subarray_problem
+"""
+from collections.abc import Sequence
+
+
+def max_subarray_sum(
+ arr: Sequence[float], allow_empty_subarrays: bool = False
+) -> float:
+ """
+ Solves the maximum subarray sum problem using Kadane's algorithm.
+ :param arr: the given array of numbers
+ :param allow_empty_subarrays: if True, then the algorithm considers empty subarrays
+
+ >>> max_subarray_sum([2, 8, 9])
+ 19
+ >>> max_subarray_sum([0, 0])
+ 0
+ >>> max_subarray_sum([-1.0, 0.0, 1.0])
+ 1.0
+ >>> max_subarray_sum([1, 2, 3, 4, -2])
+ 10
+ >>> max_subarray_sum([-2, 1, -3, 4, -1, 2, 1, -5, 4])
+ 6
+ >>> max_subarray_sum([2, 3, -9, 8, -2])
+ 8
+ >>> max_subarray_sum([-2, -3, -1, -4, -6])
+ -1
+ >>> max_subarray_sum([-2, -3, -1, -4, -6], allow_empty_subarrays=True)
+ 0
+ >>> max_subarray_sum([])
+ 0
+ """
+ if not arr:
+ return 0
+
+ max_sum = 0 if allow_empty_subarrays else float("-inf")
+ curr_sum = 0.0
+ for num in arr:
+ curr_sum = max(0 if allow_empty_subarrays else num, curr_sum + num)
+ max_sum = max(max_sum, curr_sum)
+
+ return max_sum
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod()
+
+ nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+ print(f"{max_subarray_sum(nums) = }")

DIRECTORY.md

@@ -293,7 +293,7 @@
  * [Inversions](divide_and_conquer/inversions.py)
  * [Kth Order Statistic](divide_and_conquer/kth_order_statistic.py)
  * [Max Difference Pair](divide_and_conquer/max_difference_pair.py)
- * [Max Subarray Sum](divide_and_conquer/max_subarray_sum.py)
+ * [Max Subarray](divide_and_conquer/max_subarray.py)
  * [Mergesort](divide_and_conquer/mergesort.py)
  * [Peak](divide_and_conquer/peak.py)
  * [Power](divide_and_conquer/power.py)
@@ -324,8 +324,7 @@
  * [Matrix Chain Order](dynamic_programming/matrix_chain_order.py)
  * [Max Non Adjacent Sum](dynamic_programming/max_non_adjacent_sum.py)
  * [Max Product Subarray](dynamic_programming/max_product_subarray.py)
- * [Max Sub Array](dynamic_programming/max_sub_array.py)
- * [Max Sum Contiguous Subsequence](dynamic_programming/max_sum_contiguous_subsequence.py)
+ * [Max Subarray Sum](dynamic_programming/max_subarray_sum.py)
  * [Min Distance Up Bottom](dynamic_programming/min_distance_up_bottom.py)
  * [Minimum Coin Change](dynamic_programming/minimum_coin_change.py)
  * [Minimum Cost Path](dynamic_programming/minimum_cost_path.py)
@@ -591,12 +590,10 @@
  * [Is Square Free](maths/is_square_free.py)
  * [Jaccard Similarity](maths/jaccard_similarity.py)
  * [Juggler Sequence](maths/juggler_sequence.py)
- * [Kadanes](maths/kadanes.py)
  * [Karatsuba](maths/karatsuba.py)
  * [Krishnamurthy Number](maths/krishnamurthy_number.py)
  * [Kth Lexicographic Permutation](maths/kth_lexicographic_permutation.py)
  * [Largest Of Very Large Numbers](maths/largest_of_very_large_numbers.py)
- * [Largest Subarray Sum](maths/largest_subarray_sum.py)
  * [Least Common Multiple](maths/least_common_multiple.py)
  * [Line Length](maths/line_length.py)
  * [Liouville Lambda](maths/liouville_lambda.py)
@@ -733,7 +730,6 @@
  * [Linear Congruential Generator](other/linear_congruential_generator.py)
  * [Lru Cache](other/lru_cache.py)
  * [Magicdiamondpattern](other/magicdiamondpattern.py)
- * [Maximum Subarray](other/maximum_subarray.py)
  * [Maximum Subsequence](other/maximum_subsequence.py)
  * [Nested Brackets](other/nested_brackets.py)
  * [Number Container System](other/number_container_system.py)

divide_and_conquer/max_subarray.py

@@ -0,0 +1,112 @@
+"""
+The maximum subarray problem is the task of finding the continuous subarray that has the
+maximum sum within a given array of numbers. For example, given the array
+[-2, 1, -3, 4, -1, 2, 1, -5, 4], the contiguous subarray with the maximum sum is
+[4, -1, 2, 1], which has a sum of 6.
+
+This divide-and-conquer algorithm finds the maximum subarray in O(n log n) time.
+"""
+from __future__ import annotations
+
+import time
+from collections.abc import Sequence
+from random import randint
+
+from matplotlib import pyplot as plt
+
+
+def max_subarray(
+ arr: Sequence[float], low: int, high: int
+) -> tuple[int | None, int | None, float]:
+ """
+ Solves the maximum subarray problem using divide and conquer.
+ :param arr: the given array of numbers
+ :param low: the start index
+ :param high: the end index
+ :return: the start index of the maximum subarray, the end index of the
+ maximum subarray, and the maximum subarray sum
+
+ >>> nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (3, 6, 6)
+ >>> nums = [2, 8, 9]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (0, 2, 19)
+ >>> nums = [0, 0]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (0, 0, 0)
+ >>> nums = [-1.0, 0.0, 1.0]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (2, 2, 1.0)
+ >>> nums = [-2, -3, -1, -4, -6]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (2, 2, -1)
+ >>> max_subarray([], 0, 0)
+ (None, None, 0)
+ """
+ if not arr:
+ return None, None, 0
+ if low == high:
+ return low, high, arr[low]
+
+ mid = (low + high) // 2
+ left_low, left_high, left_sum = max_subarray(arr, low, mid)
+ right_low, right_high, right_sum = max_subarray(arr, mid + 1, high)
+ cross_left, cross_right, cross_sum = max_cross_sum(arr, low, mid, high)
+ if left_sum >= right_sum and left_sum >= cross_sum:
+ return left_low, left_high, left_sum
+ elif right_sum >= left_sum and right_sum >= cross_sum:
+ return right_low, right_high, right_sum
+ return cross_left, cross_right, cross_sum
+
+
+def max_cross_sum(
+ arr: Sequence[float], low: int, mid: int, high: int
+) -> tuple[int, int, float]:
+ left_sum, max_left = float("-inf"), -1
+ right_sum, max_right = float("-inf"), -1
+
+ summ: int | float = 0
+ for i in range(mid, low - 1, -1):
+ summ += arr[i]
+ if summ > left_sum:
+ left_sum = summ
+ max_left = i
+
+ summ = 0
+ for i in range(mid + 1, high + 1):
+ summ += arr[i]
+ if summ > right_sum:
+ right_sum = summ
+ max_right = i
+
+ return max_left, max_right, (left_sum + right_sum)
+
+
+def time_max_subarray(input_size: int) -> float:
+ arr = [randint(1, input_size) for _ in range(input_size)]
+ start = time.time()
+ max_subarray(arr, 0, input_size - 1)
+ end = time.time()
+ return end - start
+
+
+def plot_runtimes() -> None:
+ input_sizes = [10, 100, 1000, 10000, 50000, 100000, 200000, 300000, 400000, 500000]
+ runtimes = [time_max_subarray(input_size) for input_size in input_sizes]
+ print("No of Inputs\t\tTime Taken")
+ for input_size, runtime in zip(input_sizes, runtimes):
+ print(input_size, "\t\t", runtime)
+ plt.plot(input_sizes, runtimes)
+ plt.xlabel("Number of Inputs")
+ plt.ylabel("Time taken in seconds")
+ plt.show()
+
+
+if __name__ == "__main__":
+ """
+ A random simulation of this algorithm.
+ """
+ from doctest import testmod
+
+ testmod()

dynamic_programming/max_subarray_sum.py

@@ -0,0 +1,60 @@
+"""
+The maximum subarray sum problem is the task of finding the maximum sum that can be
+obtained from a contiguous subarray within a given array of numbers. For example, given
+the array [-2, 1, -3, 4, -1, 2, 1, -5, 4], the contiguous subarray with the maximum sum
+is [4, -1, 2, 1], so the maximum subarray sum is 6.
+
+Kadane's algorithm is a simple dynamic programming algorithm that solves the maximum
+subarray sum problem in O(n) time and O(1) space.
+
+Reference: https://en.wikipedia.org/wiki/Maximum_subarray_problem
+"""
+from collections.abc import Sequence
+
+
+def max_subarray_sum(
+ arr: Sequence[float], allow_empty_subarrays: bool = False
+) -> float:
+ """
+ Solves the maximum subarray sum problem using Kadane's algorithm.
+ :param arr: the given array of numbers
+ :param allow_empty_subarrays: if True, then the algorithm considers empty subarrays
+
+ >>> max_subarray_sum([2, 8, 9])
+ 19
+ >>> max_subarray_sum([0, 0])
+ 0
+ >>> max_subarray_sum([-1.0, 0.0, 1.0])
+ 1.0
+ >>> max_subarray_sum([1, 2, 3, 4, -2])
+ 10
+ >>> max_subarray_sum([-2, 1, -3, 4, -1, 2, 1, -5, 4])
+ 6
+ >>> max_subarray_sum([2, 3, -9, 8, -2])
+ 8
+ >>> max_subarray_sum([-2, -3, -1, -4, -6])
+ -1
+ >>> max_subarray_sum([-2, -3, -1, -4, -6], allow_empty_subarrays=True)
+ 0
+ >>> max_subarray_sum([])
+ 0
+ """
+ if not arr:
+ return 0
+
+ max_sum = 0 if allow_empty_subarrays else float("-inf")
+ curr_sum = 0.0
+ for num in arr:
+ curr_sum = max(0 if allow_empty_subarrays else num, curr_sum + num)
+ max_sum = max(max_sum, curr_sum)
+
+ return max_sum
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod()
+
+ nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+ print(f"{max_subarray_sum(nums) = }")

DIRECTORY.md

@@ -293,7 +293,7 @@
  * [Inversions](divide_and_conquer/inversions.py)
  * [Kth Order Statistic](divide_and_conquer/kth_order_statistic.py)
  * [Max Difference Pair](divide_and_conquer/max_difference_pair.py)
- * [Max Subarray Sum](divide_and_conquer/max_subarray_sum.py)
+ * [Max Subarray](divide_and_conquer/max_subarray.py)
  * [Mergesort](divide_and_conquer/mergesort.py)
  * [Peak](divide_and_conquer/peak.py)
  * [Power](divide_and_conquer/power.py)
@@ -324,8 +324,7 @@
  * [Matrix Chain Order](dynamic_programming/matrix_chain_order.py)
  * [Max Non Adjacent Sum](dynamic_programming/max_non_adjacent_sum.py)
  * [Max Product Subarray](dynamic_programming/max_product_subarray.py)
- * [Max Sub Array](dynamic_programming/max_sub_array.py)
- * [Max Sum Contiguous Subsequence](dynamic_programming/max_sum_contiguous_subsequence.py)
+ * [Max Subarray Sum](dynamic_programming/max_subarray_sum.py)
  * [Min Distance Up Bottom](dynamic_programming/min_distance_up_bottom.py)
  * [Minimum Coin Change](dynamic_programming/minimum_coin_change.py)
  * [Minimum Cost Path](dynamic_programming/minimum_cost_path.py)
@@ -591,12 +590,10 @@
  * [Is Square Free](maths/is_square_free.py)
  * [Jaccard Similarity](maths/jaccard_similarity.py)
  * [Juggler Sequence](maths/juggler_sequence.py)
- * [Kadanes](maths/kadanes.py)
  * [Karatsuba](maths/karatsuba.py)
  * [Krishnamurthy Number](maths/krishnamurthy_number.py)
  * [Kth Lexicographic Permutation](maths/kth_lexicographic_permutation.py)
  * [Largest Of Very Large Numbers](maths/largest_of_very_large_numbers.py)
- * [Largest Subarray Sum](maths/largest_subarray_sum.py)
  * [Least Common Multiple](maths/least_common_multiple.py)
  * [Line Length](maths/line_length.py)
  * [Liouville Lambda](maths/liouville_lambda.py)
@@ -733,7 +730,6 @@
  * [Linear Congruential Generator](other/linear_congruential_generator.py)
  * [Lru Cache](other/lru_cache.py)
  * [Magicdiamondpattern](other/magicdiamondpattern.py)
- * [Maximum Subarray](other/maximum_subarray.py)
  * [Maximum Subsequence](other/maximum_subsequence.py)
  * [Nested Brackets](other/nested_brackets.py)
  * [Number Container System](other/number_container_system.py)

divide_and_conquer/max_subarray.py

@@ -0,0 +1,112 @@
+"""
+The maximum subarray problem is the task of finding the continuous subarray that has the
+maximum sum within a given array of numbers. For example, given the array
+[-2, 1, -3, 4, -1, 2, 1, -5, 4], the contiguous subarray with the maximum sum is
+[4, -1, 2, 1], which has a sum of 6.
+
+This divide-and-conquer algorithm finds the maximum subarray in O(n log n) time.
+"""
+from __future__ import annotations
+
+import time
+from collections.abc import Sequence
+from random import randint
+
+from matplotlib import pyplot as plt
+
+
+def max_subarray(
+ arr: Sequence[float], low: int, high: int
+) -> tuple[int | None, int | None, float]:
+ """
+ Solves the maximum subarray problem using divide and conquer.
+ :param arr: the given array of numbers
+ :param low: the start index
+ :param high: the end index
+ :return: the start index of the maximum subarray, the end index of the
+ maximum subarray, and the maximum subarray sum
+
+ >>> nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (3, 6, 6)
+ >>> nums = [2, 8, 9]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (0, 2, 19)
+ >>> nums = [0, 0]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (0, 0, 0)
+ >>> nums = [-1.0, 0.0, 1.0]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (2, 2, 1.0)
+ >>> nums = [-2, -3, -1, -4, -6]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (2, 2, -1)
+ >>> max_subarray([], 0, 0)
+ (None, None, 0)
+ """
+ if not arr:
+ return None, None, 0
+ if low == high:
+ return low, high, arr[low]
+
+ mid = (low + high) // 2
+ left_low, left_high, left_sum = max_subarray(arr, low, mid)
+ right_low, right_high, right_sum = max_subarray(arr, mid + 1, high)
+ cross_left, cross_right, cross_sum = max_cross_sum(arr, low, mid, high)
+ if left_sum >= right_sum and left_sum >= cross_sum:
+ return left_low, left_high, left_sum
+ elif right_sum >= left_sum and right_sum >= cross_sum:
+ return right_low, right_high, right_sum
+ return cross_left, cross_right, cross_sum
+
+
+def max_cross_sum(
+ arr: Sequence[float], low: int, mid: int, high: int
+) -> tuple[int, int, float]:
+ left_sum, max_left = float("-inf"), -1
+ right_sum, max_right = float("-inf"), -1
+
+ summ: int | float = 0
+ for i in range(mid, low - 1, -1):
+ summ += arr[i]
+ if summ > left_sum:
+ left_sum = summ
+ max_left = i
+
+ summ = 0
+ for i in range(mid + 1, high + 1):
+ summ += arr[i]
+ if summ > right_sum:
+ right_sum = summ
+ max_right = i
+
+ return max_left, max_right, (left_sum + right_sum)
+
+
+def time_max_subarray(input_size: int) -> float:
+ arr = [randint(1, input_size) for _ in range(input_size)]
+ start = time.time()
+ max_subarray(arr, 0, input_size - 1)
+ end = time.time()
+ return end - start
+
+
+def plot_runtimes() -> None:
+ input_sizes = [10, 100, 1000, 10000, 50000, 100000, 200000, 300000, 400000, 500000]
+ runtimes = [time_max_subarray(input_size) for input_size in input_sizes]
+ print("No of Inputs\t\tTime Taken")
+ for input_size, runtime in zip(input_sizes, runtimes):
+ print(input_size, "\t\t", runtime)
+ plt.plot(input_sizes, runtimes)
+ plt.xlabel("Number of Inputs")
+ plt.ylabel("Time taken in seconds")
+ plt.show()
+
+
+if __name__ == "__main__":
+ """
+ A random simulation of this algorithm.
+ """
+ from doctest import testmod
+
+ testmod()

dynamic_programming/max_subarray_sum.py

@@ -0,0 +1,60 @@
+"""
+The maximum subarray sum problem is the task of finding the maximum sum that can be
+obtained from a contiguous subarray within a given array of numbers. For example, given
+the array [-2, 1, -3, 4, -1, 2, 1, -5, 4], the contiguous subarray with the maximum sum
+is [4, -1, 2, 1], so the maximum subarray sum is 6.
+
+Kadane's algorithm is a simple dynamic programming algorithm that solves the maximum
+subarray sum problem in O(n) time and O(1) space.
+
+Reference: https://en.wikipedia.org/wiki/Maximum_subarray_problem
+"""
+from collections.abc import Sequence
+
+
+def max_subarray_sum(
+ arr: Sequence[float], allow_empty_subarrays: bool = False
+) -> float:
+ """
+ Solves the maximum subarray sum problem using Kadane's algorithm.
+ :param arr: the given array of numbers
+ :param allow_empty_subarrays: if True, then the algorithm considers empty subarrays
+
+ >>> max_subarray_sum([2, 8, 9])
+ 19
+ >>> max_subarray_sum([0, 0])
+ 0
+ >>> max_subarray_sum([-1.0, 0.0, 1.0])
+ 1.0
+ >>> max_subarray_sum([1, 2, 3, 4, -2])
+ 10
+ >>> max_subarray_sum([-2, 1, -3, 4, -1, 2, 1, -5, 4])
+ 6
+ >>> max_subarray_sum([2, 3, -9, 8, -2])
+ 8
+ >>> max_subarray_sum([-2, -3, -1, -4, -6])
+ -1
+ >>> max_subarray_sum([-2, -3, -1, -4, -6], allow_empty_subarrays=True)
+ 0
+ >>> max_subarray_sum([])
+ 0
+ """
+ if not arr:
+ return 0
+
+ max_sum = 0 if allow_empty_subarrays else float("-inf")
+ curr_sum = 0.0
+ for num in arr:
+ curr_sum = max(0 if allow_empty_subarrays else num, curr_sum + num)
+ max_sum = max(max_sum, curr_sum)
+
+ return max_sum
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod()
+
+ nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+ print(f"{max_subarray_sum(nums) = }")

DIRECTORY.md

@@ -293,7 +293,7 @@
  * [Inversions](divide_and_conquer/inversions.py)
  * [Kth Order Statistic](divide_and_conquer/kth_order_statistic.py)
  * [Max Difference Pair](divide_and_conquer/max_difference_pair.py)
- * [Max Subarray Sum](divide_and_conquer/max_subarray_sum.py)
+ * [Max Subarray](divide_and_conquer/max_subarray.py)
  * [Mergesort](divide_and_conquer/mergesort.py)
  * [Peak](divide_and_conquer/peak.py)
  * [Power](divide_and_conquer/power.py)
@@ -324,8 +324,7 @@
  * [Matrix Chain Order](dynamic_programming/matrix_chain_order.py)
  * [Max Non Adjacent Sum](dynamic_programming/max_non_adjacent_sum.py)
  * [Max Product Subarray](dynamic_programming/max_product_subarray.py)
- * [Max Sub Array](dynamic_programming/max_sub_array.py)
- * [Max Sum Contiguous Subsequence](dynamic_programming/max_sum_contiguous_subsequence.py)
+ * [Max Subarray Sum](dynamic_programming/max_subarray_sum.py)
  * [Min Distance Up Bottom](dynamic_programming/min_distance_up_bottom.py)
  * [Minimum Coin Change](dynamic_programming/minimum_coin_change.py)
  * [Minimum Cost Path](dynamic_programming/minimum_cost_path.py)
@@ -591,12 +590,10 @@
  * [Is Square Free](maths/is_square_free.py)
  * [Jaccard Similarity](maths/jaccard_similarity.py)
  * [Juggler Sequence](maths/juggler_sequence.py)
- * [Kadanes](maths/kadanes.py)
  * [Karatsuba](maths/karatsuba.py)
  * [Krishnamurthy Number](maths/krishnamurthy_number.py)
  * [Kth Lexicographic Permutation](maths/kth_lexicographic_permutation.py)
  * [Largest Of Very Large Numbers](maths/largest_of_very_large_numbers.py)
- * [Largest Subarray Sum](maths/largest_subarray_sum.py)
  * [Least Common Multiple](maths/least_common_multiple.py)
  * [Line Length](maths/line_length.py)
  * [Liouville Lambda](maths/liouville_lambda.py)
@@ -733,7 +730,6 @@
  * [Linear Congruential Generator](other/linear_congruential_generator.py)
  * [Lru Cache](other/lru_cache.py)
  * [Magicdiamondpattern](other/magicdiamondpattern.py)
- * [Maximum Subarray](other/maximum_subarray.py)
  * [Maximum Subsequence](other/maximum_subsequence.py)
  * [Nested Brackets](other/nested_brackets.py)
  * [Number Container System](other/number_container_system.py)

divide_and_conquer/max_subarray.py

@@ -0,0 +1,112 @@
+"""
+The maximum subarray problem is the task of finding the continuous subarray that has the
+maximum sum within a given array of numbers. For example, given the array
+[-2, 1, -3, 4, -1, 2, 1, -5, 4], the contiguous subarray with the maximum sum is
+[4, -1, 2, 1], which has a sum of 6.
+
+This divide-and-conquer algorithm finds the maximum subarray in O(n log n) time.
+"""
+from __future__ import annotations
+
+import time
+from collections.abc import Sequence
+from random import randint
+
+from matplotlib import pyplot as plt
+
+
+def max_subarray(
+ arr: Sequence[float], low: int, high: int
+) -> tuple[int | None, int | None, float]:
+ """
+ Solves the maximum subarray problem using divide and conquer.
+ :param arr: the given array of numbers
+ :param low: the start index
+ :param high: the end index
+ :return: the start index of the maximum subarray, the end index of the
+ maximum subarray, and the maximum subarray sum
+
+ >>> nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (3, 6, 6)
+ >>> nums = [2, 8, 9]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (0, 2, 19)
+ >>> nums = [0, 0]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (0, 0, 0)
+ >>> nums = [-1.0, 0.0, 1.0]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (2, 2, 1.0)
+ >>> nums = [-2, -3, -1, -4, -6]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (2, 2, -1)
+ >>> max_subarray([], 0, 0)
+ (None, None, 0)
+ """
+ if not arr:
+ return None, None, 0
+ if low == high:
+ return low, high, arr[low]
+
+ mid = (low + high) // 2
+ left_low, left_high, left_sum = max_subarray(arr, low, mid)
+ right_low, right_high, right_sum = max_subarray(arr, mid + 1, high)
+ cross_left, cross_right, cross_sum = max_cross_sum(arr, low, mid, high)
+ if left_sum >= right_sum and left_sum >= cross_sum:
+ return left_low, left_high, left_sum
+ elif right_sum >= left_sum and right_sum >= cross_sum:
+ return right_low, right_high, right_sum
+ return cross_left, cross_right, cross_sum
+
+
+def max_cross_sum(
+ arr: Sequence[float], low: int, mid: int, high: int
+) -> tuple[int, int, float]:
+ left_sum, max_left = float("-inf"), -1
+ right_sum, max_right = float("-inf"), -1
+
+ summ: int | float = 0
+ for i in range(mid, low - 1, -1):
+ summ += arr[i]
+ if summ > left_sum:
+ left_sum = summ
+ max_left = i
+
+ summ = 0
+ for i in range(mid + 1, high + 1):
+ summ += arr[i]
+ if summ > right_sum:
+ right_sum = summ
+ max_right = i
+
+ return max_left, max_right, (left_sum + right_sum)
+
+
+def time_max_subarray(input_size: int) -> float:
+ arr = [randint(1, input_size) for _ in range(input_size)]
+ start = time.time()
+ max_subarray(arr, 0, input_size - 1)
+ end = time.time()
+ return end - start
+
+
+def plot_runtimes() -> None:
+ input_sizes = [10, 100, 1000, 10000, 50000, 100000, 200000, 300000, 400000, 500000]
+ runtimes = [time_max_subarray(input_size) for input_size in input_sizes]
+ print("No of Inputs\t\tTime Taken")
+ for input_size, runtime in zip(input_sizes, runtimes):
+ print(input_size, "\t\t", runtime)
+ plt.plot(input_sizes, runtimes)
+ plt.xlabel("Number of Inputs")
+ plt.ylabel("Time taken in seconds")
+ plt.show()
+
+
+if __name__ == "__main__":
+ """
+ A random simulation of this algorithm.
+ """
+ from doctest import testmod
+
+ testmod()

dynamic_programming/max_subarray_sum.py

@@ -0,0 +1,60 @@
+"""
+The maximum subarray sum problem is the task of finding the maximum sum that can be
+obtained from a contiguous subarray within a given array of numbers. For example, given
+the array [-2, 1, -3, 4, -1, 2, 1, -5, 4], the contiguous subarray with the maximum sum
+is [4, -1, 2, 1], so the maximum subarray sum is 6.
+
+Kadane's algorithm is a simple dynamic programming algorithm that solves the maximum
+subarray sum problem in O(n) time and O(1) space.
+
+Reference: https://en.wikipedia.org/wiki/Maximum_subarray_problem
+"""
+from collections.abc import Sequence
+
+
+def max_subarray_sum(
+ arr: Sequence[float], allow_empty_subarrays: bool = False
+) -> float:
+ """
+ Solves the maximum subarray sum problem using Kadane's algorithm.
+ :param arr: the given array of numbers
+ :param allow_empty_subarrays: if True, then the algorithm considers empty subarrays
+
+ >>> max_subarray_sum([2, 8, 9])
+ 19
+ >>> max_subarray_sum([0, 0])
+ 0
+ >>> max_subarray_sum([-1.0, 0.0, 1.0])
+ 1.0
+ >>> max_subarray_sum([1, 2, 3, 4, -2])
+ 10
+ >>> max_subarray_sum([-2, 1, -3, 4, -1, 2, 1, -5, 4])
+ 6
+ >>> max_subarray_sum([2, 3, -9, 8, -2])
+ 8
+ >>> max_subarray_sum([-2, -3, -1, -4, -6])
+ -1
+ >>> max_subarray_sum([-2, -3, -1, -4, -6], allow_empty_subarrays=True)
+ 0
+ >>> max_subarray_sum([])
+ 0
+ """
+ if not arr:
+ return 0
+
+ max_sum = 0 if allow_empty_subarrays else float("-inf")
+ curr_sum = 0.0
+ for num in arr:
+ curr_sum = max(0 if allow_empty_subarrays else num, curr_sum + num)
+ max_sum = max(max_sum, curr_sum)
+
+ return max_sum
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod()
+
+ nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+ print(f"{max_subarray_sum(nums) = }")

DIRECTORY.md

@@ -293,7 +293,7 @@
  * [Inversions](divide_and_conquer/inversions.py)
  * [Kth Order Statistic](divide_and_conquer/kth_order_statistic.py)
  * [Max Difference Pair](divide_and_conquer/max_difference_pair.py)
- * [Max Subarray Sum](divide_and_conquer/max_subarray_sum.py)
+ * [Max Subarray](divide_and_conquer/max_subarray.py)
  * [Mergesort](divide_and_conquer/mergesort.py)
  * [Peak](divide_and_conquer/peak.py)
  * [Power](divide_and_conquer/power.py)
@@ -324,8 +324,7 @@
  * [Matrix Chain Order](dynamic_programming/matrix_chain_order.py)
  * [Max Non Adjacent Sum](dynamic_programming/max_non_adjacent_sum.py)
  * [Max Product Subarray](dynamic_programming/max_product_subarray.py)
- * [Max Sub Array](dynamic_programming/max_sub_array.py)
- * [Max Sum Contiguous Subsequence](dynamic_programming/max_sum_contiguous_subsequence.py)
+ * [Max Subarray Sum](dynamic_programming/max_subarray_sum.py)
  * [Min Distance Up Bottom](dynamic_programming/min_distance_up_bottom.py)
  * [Minimum Coin Change](dynamic_programming/minimum_coin_change.py)
  * [Minimum Cost Path](dynamic_programming/minimum_cost_path.py)
@@ -591,12 +590,10 @@
  * [Is Square Free](maths/is_square_free.py)
  * [Jaccard Similarity](maths/jaccard_similarity.py)
  * [Juggler Sequence](maths/juggler_sequence.py)
- * [Kadanes](maths/kadanes.py)
  * [Karatsuba](maths/karatsuba.py)
  * [Krishnamurthy Number](maths/krishnamurthy_number.py)
  * [Kth Lexicographic Permutation](maths/kth_lexicographic_permutation.py)
  * [Largest Of Very Large Numbers](maths/largest_of_very_large_numbers.py)
- * [Largest Subarray Sum](maths/largest_subarray_sum.py)
  * [Least Common Multiple](maths/least_common_multiple.py)
  * [Line Length](maths/line_length.py)
  * [Liouville Lambda](maths/liouville_lambda.py)
@@ -733,7 +730,6 @@
  * [Linear Congruential Generator](other/linear_congruential_generator.py)
  * [Lru Cache](other/lru_cache.py)
  * [Magicdiamondpattern](other/magicdiamondpattern.py)
- * [Maximum Subarray](other/maximum_subarray.py)
  * [Maximum Subsequence](other/maximum_subsequence.py)
  * [Nested Brackets](other/nested_brackets.py)
  * [Number Container System](other/number_container_system.py)

divide_and_conquer/max_subarray.py

@@ -0,0 +1,112 @@
+"""
+The maximum subarray problem is the task of finding the continuous subarray that has the
+maximum sum within a given array of numbers. For example, given the array
+[-2, 1, -3, 4, -1, 2, 1, -5, 4], the contiguous subarray with the maximum sum is
+[4, -1, 2, 1], which has a sum of 6.
+
+This divide-and-conquer algorithm finds the maximum subarray in O(n log n) time.
+"""
+from __future__ import annotations
+
+import time
+from collections.abc import Sequence
+from random import randint
+
+from matplotlib import pyplot as plt
+
+
+def max_subarray(
+ arr: Sequence[float], low: int, high: int
+) -> tuple[int | None, int | None, float]:
+ """
+ Solves the maximum subarray problem using divide and conquer.
+ :param arr: the given array of numbers
+ :param low: the start index
+ :param high: the end index
+ :return: the start index of the maximum subarray, the end index of the
+ maximum subarray, and the maximum subarray sum
+
+ >>> nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (3, 6, 6)
+ >>> nums = [2, 8, 9]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (0, 2, 19)
+ >>> nums = [0, 0]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (0, 0, 0)
+ >>> nums = [-1.0, 0.0, 1.0]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (2, 2, 1.0)
+ >>> nums = [-2, -3, -1, -4, -6]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (2, 2, -1)
+ >>> max_subarray([], 0, 0)
+ (None, None, 0)
+ """
+ if not arr:
+ return None, None, 0
+ if low == high:
+ return low, high, arr[low]
+
+ mid = (low + high) // 2
+ left_low, left_high, left_sum = max_subarray(arr, low, mid)
+ right_low, right_high, right_sum = max_subarray(arr, mid + 1, high)
+ cross_left, cross_right, cross_sum = max_cross_sum(arr, low, mid, high)
+ if left_sum >= right_sum and left_sum >= cross_sum:
+ return left_low, left_high, left_sum
+ elif right_sum >= left_sum and right_sum >= cross_sum:
+ return right_low, right_high, right_sum
+ return cross_left, cross_right, cross_sum
+
+
+def max_cross_sum(
+ arr: Sequence[float], low: int, mid: int, high: int
+) -> tuple[int, int, float]:
+ left_sum, max_left = float("-inf"), -1
+ right_sum, max_right = float("-inf"), -1
+
+ summ: int | float = 0
+ for i in range(mid, low - 1, -1):
+ summ += arr[i]
+ if summ > left_sum:
+ left_sum = summ
+ max_left = i
+
+ summ = 0
+ for i in range(mid + 1, high + 1):
+ summ += arr[i]
+ if summ > right_sum:
+ right_sum = summ
+ max_right = i
+
+ return max_left, max_right, (left_sum + right_sum)
+
+
+def time_max_subarray(input_size: int) -> float:
+ arr = [randint(1, input_size) for _ in range(input_size)]
+ start = time.time()
+ max_subarray(arr, 0, input_size - 1)
+ end = time.time()
+ return end - start
+
+
+def plot_runtimes() -> None:
+ input_sizes = [10, 100, 1000, 10000, 50000, 100000, 200000, 300000, 400000, 500000]
+ runtimes = [time_max_subarray(input_size) for input_size in input_sizes]
+ print("No of Inputs\t\tTime Taken")
+ for input_size, runtime in zip(input_sizes, runtimes):
+ print(input_size, "\t\t", runtime)
+ plt.plot(input_sizes, runtimes)
+ plt.xlabel("Number of Inputs")
+ plt.ylabel("Time taken in seconds")
+ plt.show()
+
+
+if __name__ == "__main__":
+ """
+ A random simulation of this algorithm.
+ """
+ from doctest import testmod
+
+ testmod()

dynamic_programming/max_subarray_sum.py

@@ -0,0 +1,60 @@
+"""
+The maximum subarray sum problem is the task of finding the maximum sum that can be
+obtained from a contiguous subarray within a given array of numbers. For example, given
+the array [-2, 1, -3, 4, -1, 2, 1, -5, 4], the contiguous subarray with the maximum sum
+is [4, -1, 2, 1], so the maximum subarray sum is 6.
+
+Kadane's algorithm is a simple dynamic programming algorithm that solves the maximum
+subarray sum problem in O(n) time and O(1) space.
+
+Reference: https://en.wikipedia.org/wiki/Maximum_subarray_problem
+"""
+from collections.abc import Sequence
+
+
+def max_subarray_sum(
+ arr: Sequence[float], allow_empty_subarrays: bool = False
+) -> float:
+ """
+ Solves the maximum subarray sum problem using Kadane's algorithm.
+ :param arr: the given array of numbers
+ :param allow_empty_subarrays: if True, then the algorithm considers empty subarrays
+
+ >>> max_subarray_sum([2, 8, 9])
+ 19
+ >>> max_subarray_sum([0, 0])
+ 0
+ >>> max_subarray_sum([-1.0, 0.0, 1.0])
+ 1.0
+ >>> max_subarray_sum([1, 2, 3, 4, -2])
+ 10
+ >>> max_subarray_sum([-2, 1, -3, 4, -1, 2, 1, -5, 4])
+ 6
+ >>> max_subarray_sum([2, 3, -9, 8, -2])
+ 8
+ >>> max_subarray_sum([-2, -3, -1, -4, -6])
+ -1
+ >>> max_subarray_sum([-2, -3, -1, -4, -6], allow_empty_subarrays=True)
+ 0
+ >>> max_subarray_sum([])
+ 0
+ """
+ if not arr:
+ return 0
+
+ max_sum = 0 if allow_empty_subarrays else float("-inf")
+ curr_sum = 0.0
+ for num in arr:
+ curr_sum = max(0 if allow_empty_subarrays else num, curr_sum + num)
+ max_sum = max(max_sum, curr_sum)
+
+ return max_sum
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod()
+
+ nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+ print(f"{max_subarray_sum(nums) = }")

DIRECTORY.md

@@ -293,7 +293,7 @@
  * [Inversions](divide_and_conquer/inversions.py)
  * [Kth Order Statistic](divide_and_conquer/kth_order_statistic.py)
  * [Max Difference Pair](divide_and_conquer/max_difference_pair.py)
- * [Max Subarray Sum](divide_and_conquer/max_subarray_sum.py)
+ * [Max Subarray](divide_and_conquer/max_subarray.py)
  * [Mergesort](divide_and_conquer/mergesort.py)
  * [Peak](divide_and_conquer/peak.py)
  * [Power](divide_and_conquer/power.py)
@@ -324,8 +324,7 @@
  * [Matrix Chain Order](dynamic_programming/matrix_chain_order.py)
  * [Max Non Adjacent Sum](dynamic_programming/max_non_adjacent_sum.py)
  * [Max Product Subarray](dynamic_programming/max_product_subarray.py)
- * [Max Sub Array](dynamic_programming/max_sub_array.py)
- * [Max Sum Contiguous Subsequence](dynamic_programming/max_sum_contiguous_subsequence.py)
+ * [Max Subarray Sum](dynamic_programming/max_subarray_sum.py)
  * [Min Distance Up Bottom](dynamic_programming/min_distance_up_bottom.py)
  * [Minimum Coin Change](dynamic_programming/minimum_coin_change.py)
  * [Minimum Cost Path](dynamic_programming/minimum_cost_path.py)
@@ -591,12 +590,10 @@
  * [Is Square Free](maths/is_square_free.py)
  * [Jaccard Similarity](maths/jaccard_similarity.py)
  * [Juggler Sequence](maths/juggler_sequence.py)
- * [Kadanes](maths/kadanes.py)
  * [Karatsuba](maths/karatsuba.py)
  * [Krishnamurthy Number](maths/krishnamurthy_number.py)
  * [Kth Lexicographic Permutation](maths/kth_lexicographic_permutation.py)
  * [Largest Of Very Large Numbers](maths/largest_of_very_large_numbers.py)
- * [Largest Subarray Sum](maths/largest_subarray_sum.py)
  * [Least Common Multiple](maths/least_common_multiple.py)
  * [Line Length](maths/line_length.py)
  * [Liouville Lambda](maths/liouville_lambda.py)
@@ -733,7 +730,6 @@
  * [Linear Congruential Generator](other/linear_congruential_generator.py)
  * [Lru Cache](other/lru_cache.py)
  * [Magicdiamondpattern](other/magicdiamondpattern.py)
- * [Maximum Subarray](other/maximum_subarray.py)
  * [Maximum Subsequence](other/maximum_subsequence.py)
  * [Nested Brackets](other/nested_brackets.py)
  * [Number Container System](other/number_container_system.py)

divide_and_conquer/max_subarray.py

@@ -0,0 +1,112 @@
+"""
+The maximum subarray problem is the task of finding the continuous subarray that has the
+maximum sum within a given array of numbers. For example, given the array
+[-2, 1, -3, 4, -1, 2, 1, -5, 4], the contiguous subarray with the maximum sum is
+[4, -1, 2, 1], which has a sum of 6.
+
+This divide-and-conquer algorithm finds the maximum subarray in O(n log n) time.
+"""
+from __future__ import annotations
+
+import time
+from collections.abc import Sequence
+from random import randint
+
+from matplotlib import pyplot as plt
+
+
+def max_subarray(
+ arr: Sequence[float], low: int, high: int
+) -> tuple[int | None, int | None, float]:
+ """
+ Solves the maximum subarray problem using divide and conquer.
+ :param arr: the given array of numbers
+ :param low: the start index
+ :param high: the end index
+ :return: the start index of the maximum subarray, the end index of the
+ maximum subarray, and the maximum subarray sum
+
+ >>> nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (3, 6, 6)
+ >>> nums = [2, 8, 9]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (0, 2, 19)
+ >>> nums = [0, 0]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (0, 0, 0)
+ >>> nums = [-1.0, 0.0, 1.0]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (2, 2, 1.0)
+ >>> nums = [-2, -3, -1, -4, -6]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (2, 2, -1)
+ >>> max_subarray([], 0, 0)
+ (None, None, 0)
+ """
+ if not arr:
+ return None, None, 0
+ if low == high:
+ return low, high, arr[low]
+
+ mid = (low + high) // 2
+ left_low, left_high, left_sum = max_subarray(arr, low, mid)
+ right_low, right_high, right_sum = max_subarray(arr, mid + 1, high)
+ cross_left, cross_right, cross_sum = max_cross_sum(arr, low, mid, high)
+ if left_sum >= right_sum and left_sum >= cross_sum:
+ return left_low, left_high, left_sum
+ elif right_sum >= left_sum and right_sum >= cross_sum:
+ return right_low, right_high, right_sum
+ return cross_left, cross_right, cross_sum
+
+
+def max_cross_sum(
+ arr: Sequence[float], low: int, mid: int, high: int
+) -> tuple[int, int, float]:
+ left_sum, max_left = float("-inf"), -1
+ right_sum, max_right = float("-inf"), -1
+
+ summ: int | float = 0
+ for i in range(mid, low - 1, -1):
+ summ += arr[i]
+ if summ > left_sum:
+ left_sum = summ
+ max_left = i
+
+ summ = 0
+ for i in range(mid + 1, high + 1):
+ summ += arr[i]
+ if summ > right_sum:
+ right_sum = summ
+ max_right = i
+
+ return max_left, max_right, (left_sum + right_sum)
+
+
+def time_max_subarray(input_size: int) -> float:
+ arr = [randint(1, input_size) for _ in range(input_size)]
+ start = time.time()
+ max_subarray(arr, 0, input_size - 1)
+ end = time.time()
+ return end - start
+
+
+def plot_runtimes() -> None:
+ input_sizes = [10, 100, 1000, 10000, 50000, 100000, 200000, 300000, 400000, 500000]
+ runtimes = [time_max_subarray(input_size) for input_size in input_sizes]
+ print("No of Inputs\t\tTime Taken")
+ for input_size, runtime in zip(input_sizes, runtimes):
+ print(input_size, "\t\t", runtime)
+ plt.plot(input_sizes, runtimes)
+ plt.xlabel("Number of Inputs")
+ plt.ylabel("Time taken in seconds")
+ plt.show()
+
+
+if __name__ == "__main__":
+ """
+ A random simulation of this algorithm.
+ """
+ from doctest import testmod
+
+ testmod()

dynamic_programming/max_subarray_sum.py

@@ -0,0 +1,60 @@
+"""
+The maximum subarray sum problem is the task of finding the maximum sum that can be
+obtained from a contiguous subarray within a given array of numbers. For example, given
+the array [-2, 1, -3, 4, -1, 2, 1, -5, 4], the contiguous subarray with the maximum sum
+is [4, -1, 2, 1], so the maximum subarray sum is 6.
+
+Kadane's algorithm is a simple dynamic programming algorithm that solves the maximum
+subarray sum problem in O(n) time and O(1) space.
+
+Reference: https://en.wikipedia.org/wiki/Maximum_subarray_problem
+"""
+from collections.abc import Sequence
+
+
+def max_subarray_sum(
+ arr: Sequence[float], allow_empty_subarrays: bool = False
+) -> float:
+ """
+ Solves the maximum subarray sum problem using Kadane's algorithm.
+ :param arr: the given array of numbers
+ :param allow_empty_subarrays: if True, then the algorithm considers empty subarrays
+
+ >>> max_subarray_sum([2, 8, 9])
+ 19
+ >>> max_subarray_sum([0, 0])
+ 0
+ >>> max_subarray_sum([-1.0, 0.0, 1.0])
+ 1.0
+ >>> max_subarray_sum([1, 2, 3, 4, -2])
+ 10
+ >>> max_subarray_sum([-2, 1, -3, 4, -1, 2, 1, -5, 4])
+ 6
+ >>> max_subarray_sum([2, 3, -9, 8, -2])
+ 8
+ >>> max_subarray_sum([-2, -3, -1, -4, -6])
+ -1
+ >>> max_subarray_sum([-2, -3, -1, -4, -6], allow_empty_subarrays=True)
+ 0
+ >>> max_subarray_sum([])
+ 0
+ """
+ if not arr:
+ return 0
+
+ max_sum = 0 if allow_empty_subarrays else float("-inf")
+ curr_sum = 0.0
+ for num in arr:
+ curr_sum = max(0 if allow_empty_subarrays else num, curr_sum + num)
+ max_sum = max(max_sum, curr_sum)
+
+ return max_sum
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod()
+
+ nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+ print(f"{max_subarray_sum(nums) = }")