From ecd0580f4d62723248db272e5864d05b6e178415 Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Tue, 28 Mar 2023 23:29:59 +0530
Subject: [PATCH 01/41] added a problem with solution on sliding window.

---
 sliding_window/minimum_size_subarray_sum.py | 35 +++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 sliding_window/minimum_size_subarray_sum.py

diff --git a/sliding_window/minimum_size_subarray_sum.py b/sliding_window/minimum_size_subarray_sum.py
new file mode 100644
index 000000000000..69135b4a41ca
--- /dev/null
+++ b/sliding_window/minimum_size_subarray_sum.py
@@ -0,0 +1,35 @@
+def minsubarraysum(target, nums):
+    """Returns the length of the shortest contiguous subarray
+       in nums whose sum is at least target.
+
+        Args:
+            target (int): The minimum sum that the subarray should have.
+            nums (list of int): The array to search for subarrays in.
+
+        Returns:
+            int: The length of the shortest contiguous subarray in nums whose
+            sum is at least target. If no such subarray exists, returns 0.
+        """
+    n = len(nums)
+    if n == 0:
+        return 0
+
+    left = 0
+    right = 0
+    curr_sum = 0
+    min_len = float("inf")
+
+    while right < n:
+        curr_sum += nums[right]
+        while curr_sum >= target:
+            min_len = min(min_len, right - left + 1)
+            curr_sum -= nums[left]
+            left += 1
+        right += 1
+
+    return min_len if min_len != float("inf") else 0
+
+
+nums = [2, 3, 1, 2, 4, 3]
+target = 7
+print(minsubarraysum(target, nums))

From ccf8634ca742aa476b856b00d4bf0c17e7e59cff Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 28 Mar 2023 18:01:24 +0000
Subject: [PATCH 02/41] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 sliding_window/minimum_size_subarray_sum.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/sliding_window/minimum_size_subarray_sum.py b/sliding_window/minimum_size_subarray_sum.py
index 69135b4a41ca..867308b8d9c1 100644
--- a/sliding_window/minimum_size_subarray_sum.py
+++ b/sliding_window/minimum_size_subarray_sum.py
@@ -1,15 +1,15 @@
 def minsubarraysum(target, nums):
     """Returns the length of the shortest contiguous subarray
-       in nums whose sum is at least target.
+    in nums whose sum is at least target.
 
-        Args:
-            target (int): The minimum sum that the subarray should have.
-            nums (list of int): The array to search for subarrays in.
+     Args:
+         target (int): The minimum sum that the subarray should have.
+         nums (list of int): The array to search for subarrays in.
 
-        Returns:
-            int: The length of the shortest contiguous subarray in nums whose
-            sum is at least target. If no such subarray exists, returns 0.
-        """
+     Returns:
+         int: The length of the shortest contiguous subarray in nums whose
+         sum is at least target. If no such subarray exists, returns 0.
+    """
     n = len(nums)
     if n == 0:
         return 0

From d621e2e4c8e87e66b35b4d36fec2c6b39d8db05e Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Tue, 28 Mar 2023 23:40:16 +0530
Subject: [PATCH 03/41] added hint for return type and parameter

---
 sliding_window/minimum_size_subarray_sum.py | 25 ++++++++++++++-------
 1 file changed, 17 insertions(+), 8 deletions(-)

diff --git a/sliding_window/minimum_size_subarray_sum.py b/sliding_window/minimum_size_subarray_sum.py
index 867308b8d9c1..d9ab2ed045d8 100644
--- a/sliding_window/minimum_size_subarray_sum.py
+++ b/sliding_window/minimum_size_subarray_sum.py
@@ -1,14 +1,23 @@
-def minsubarraysum(target, nums):
-    """Returns the length of the shortest contiguous subarray
+def minsubarraysum(target: int, nums: List[int]) -> int:
+   """
+    Returns the length of the shortest contiguous subarray 
     in nums whose sum is at least target.
 
-     Args:
-         target (int): The minimum sum that the subarray should have.
-         nums (list of int): The array to search for subarrays in.
+    Args:
+        target (int): The minimum sum that the subarray should have.
+        nums (List[int]): The array to search for subarrays in.
 
-     Returns:
-         int: The length of the shortest contiguous subarray in nums whose
-         sum is at least target. If no such subarray exists, returns 0.
+    Returns:
+        int: The length of the shortest contiguous subarray 
+        in nums whose sum is at least target. If no such subarray exists, returns 0.
+
+    Examples:
+        >>> minsubarraysum(7, [2, 3, 1, 2, 4, 3])
+        2
+        >>> minsubarraysum(4, [1, 4, 4])
+        1
+        >>> minsubarraysum(11, [1, 1, 1, 1, 1, 1, 1, 1])
+        0
     """
     n = len(nums)
     if n == 0:

From 26fb18a9d41301fd478c2a5445e960422450662a Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 28 Mar 2023 18:10:40 +0000
Subject: [PATCH 04/41] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 sliding_window/minimum_size_subarray_sum.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/sliding_window/minimum_size_subarray_sum.py b/sliding_window/minimum_size_subarray_sum.py
index d9ab2ed045d8..20e42fd84016 100644
--- a/sliding_window/minimum_size_subarray_sum.py
+++ b/sliding_window/minimum_size_subarray_sum.py
@@ -1,6 +1,6 @@
 def minsubarraysum(target: int, nums: List[int]) -> int:
    """
-    Returns the length of the shortest contiguous subarray 
+    Returns the length of the shortest contiguous subarray
     in nums whose sum is at least target.
 
     Args:
@@ -8,7 +8,7 @@ def minsubarraysum(target: int, nums: List[int]) -> int:
         nums (List[int]): The array to search for subarrays in.
 
     Returns:
-        int: The length of the shortest contiguous subarray 
+        int: The length of the shortest contiguous subarray
         in nums whose sum is at least target. If no such subarray exists, returns 0.
 
     Examples:

From 36024f664f8f1a960ec599136485c0d7ed1d237e Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Tue, 28 Mar 2023 23:44:21 +0530
Subject: [PATCH 05/41] Update minimum_size_subarray_sum.py

---
 sliding_window/minimum_size_subarray_sum.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/sliding_window/minimum_size_subarray_sum.py b/sliding_window/minimum_size_subarray_sum.py
index 20e42fd84016..469b2c5d5520 100644
--- a/sliding_window/minimum_size_subarray_sum.py
+++ b/sliding_window/minimum_size_subarray_sum.py
@@ -19,8 +19,9 @@ def minsubarraysum(target: int, nums: List[int]) -> int:
         >>> minsubarraysum(11, [1, 1, 1, 1, 1, 1, 1, 1])
         0
     """
+    
     n = len(nums)
-    if n == 0:
+    if(n == 0):
         return 0
 
     left = 0

From 2fa46db3447703211cb6c8ab0220a33dd4d7885c Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 28 Mar 2023 18:15:12 +0000
Subject: [PATCH 06/41] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 sliding_window/minimum_size_subarray_sum.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sliding_window/minimum_size_subarray_sum.py b/sliding_window/minimum_size_subarray_sum.py
index 469b2c5d5520..6f26b436beff 100644
--- a/sliding_window/minimum_size_subarray_sum.py
+++ b/sliding_window/minimum_size_subarray_sum.py
@@ -19,7 +19,7 @@ def minsubarraysum(target: int, nums: List[int]) -> int:
         >>> minsubarraysum(11, [1, 1, 1, 1, 1, 1, 1, 1])
         0
     """
-    
+
     n = len(nums)
     if(n == 0):
         return 0

From 21136aabcb373a200fc11653fbe8cde7beb9838c Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Tue, 28 Mar 2023 23:47:10 +0530
Subject: [PATCH 07/41] Update minimum_size_subarray_sum.py

---
 sliding_window/minimum_size_subarray_sum.py | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/sliding_window/minimum_size_subarray_sum.py b/sliding_window/minimum_size_subarray_sum.py
index 6f26b436beff..d0b6a502fc6d 100644
--- a/sliding_window/minimum_size_subarray_sum.py
+++ b/sliding_window/minimum_size_subarray_sum.py
@@ -14,14 +14,10 @@ def minsubarraysum(target: int, nums: List[int]) -> int:
     Examples:
         >>> minsubarraysum(7, [2, 3, 1, 2, 4, 3])
         2
-        >>> minsubarraysum(4, [1, 4, 4])
-        1
-        >>> minsubarraysum(11, [1, 1, 1, 1, 1, 1, 1, 1])
-        0
     """
 
     n = len(nums)
-    if(n == 0):
+    if n == 0:
         return 0
 
     left = 0
@@ -40,6 +36,4 @@ def minsubarraysum(target: int, nums: List[int]) -> int:
     return min_len if min_len != float("inf") else 0
 
 
-nums = [2, 3, 1, 2, 4, 3]
-target = 7
-print(minsubarraysum(target, nums))
+

From 79319046e82ec892d36d11a96a2ea1121b4fa087 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 28 Mar 2023 18:17:36 +0000
Subject: [PATCH 08/41] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 sliding_window/minimum_size_subarray_sum.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/sliding_window/minimum_size_subarray_sum.py b/sliding_window/minimum_size_subarray_sum.py
index d0b6a502fc6d..a331b4a6a56c 100644
--- a/sliding_window/minimum_size_subarray_sum.py
+++ b/sliding_window/minimum_size_subarray_sum.py
@@ -34,6 +34,3 @@ def minsubarraysum(target: int, nums: List[int]) -> int:
         right += 1
 
     return min_len if min_len != float("inf") else 0
-
-
-

From c6fabb4f2c1967959d3e220636b83a214fe92d7d Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Tue, 28 Mar 2023 23:50:02 +0530
Subject: [PATCH 09/41] Update minimum_size_subarray_sum.py

---
 sliding_window/minimum_size_subarray_sum.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/sliding_window/minimum_size_subarray_sum.py b/sliding_window/minimum_size_subarray_sum.py
index a331b4a6a56c..e8acc46ab10a 100644
--- a/sliding_window/minimum_size_subarray_sum.py
+++ b/sliding_window/minimum_size_subarray_sum.py
@@ -15,7 +15,6 @@ def minsubarraysum(target: int, nums: List[int]) -> int:
         >>> minsubarraysum(7, [2, 3, 1, 2, 4, 3])
         2
     """
-
     n = len(nums)
     if n == 0:
         return 0

From 94d638f46e4886620afc6b9d8b65dd18695f78c5 Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Tue, 28 Mar 2023 23:54:27 +0530
Subject: [PATCH 10/41] Update minimum_size_subarray_sum.py

---
 sliding_window/minimum_size_subarray_sum.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/sliding_window/minimum_size_subarray_sum.py b/sliding_window/minimum_size_subarray_sum.py
index e8acc46ab10a..4b3f36b88b88 100644
--- a/sliding_window/minimum_size_subarray_sum.py
+++ b/sliding_window/minimum_size_subarray_sum.py
@@ -1,7 +1,9 @@
-def minsubarraysum(target: int, nums: List[int]) -> int:
-   """
+
+
+def minsubarraysum(target: int, nums: list[int]) -> int:
+    """
     Returns the length of the shortest contiguous subarray
-    in nums whose sum is at least target.
+     in nums whose sum is at least target.
 
     Args:
         target (int): The minimum sum that the subarray should have.

From b4d9efc905d889260ad56711e21fe10902e6c407 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 28 Mar 2023 18:25:11 +0000
Subject: [PATCH 11/41] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 sliding_window/minimum_size_subarray_sum.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/sliding_window/minimum_size_subarray_sum.py b/sliding_window/minimum_size_subarray_sum.py
index 4b3f36b88b88..8437f312350d 100644
--- a/sliding_window/minimum_size_subarray_sum.py
+++ b/sliding_window/minimum_size_subarray_sum.py
@@ -1,5 +1,3 @@
-
-
 def minsubarraysum(target: int, nums: list[int]) -> int:
     """
     Returns the length of the shortest contiguous subarray

From 7eb87fe6043d656284f06198d2ccf4b23a480852 Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Wed, 29 Mar 2023 00:01:37 +0530
Subject: [PATCH 12/41] Update minimum_size_subarray_sum.py

---
 sliding_window/minimum_size_subarray_sum.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/sliding_window/minimum_size_subarray_sum.py b/sliding_window/minimum_size_subarray_sum.py
index 8437f312350d..2755133726d3 100644
--- a/sliding_window/minimum_size_subarray_sum.py
+++ b/sliding_window/minimum_size_subarray_sum.py
@@ -5,7 +5,7 @@ def minsubarraysum(target: int, nums: list[int]) -> int:
 
     Args:
         target (int): The minimum sum that the subarray should have.
-        nums (List[int]): The array to search for subarrays in.
+        nums (list[int]): The array to search for subarrays in.
 
     Returns:
         int: The length of the shortest contiguous subarray
@@ -32,4 +32,4 @@ def minsubarraysum(target: int, nums: list[int]) -> int:
             left += 1
         right += 1
 
-    return min_len if min_len != float("inf") else 0
+    return int(min_len) if min_len != float("inf") else 0

From 06915bf40c0c577613cd8cd91e0683b9df84be52 Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Wed, 29 Mar 2023 09:34:35 +0530
Subject: [PATCH 13/41] removed un-necessary docs and added 2 test cases

---
 sliding_window/minimum_size_subarray_sum.py | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/sliding_window/minimum_size_subarray_sum.py b/sliding_window/minimum_size_subarray_sum.py
index 2755133726d3..80664e2c751b 100644
--- a/sliding_window/minimum_size_subarray_sum.py
+++ b/sliding_window/minimum_size_subarray_sum.py
@@ -3,17 +3,13 @@ def minsubarraysum(target: int, nums: list[int]) -> int:
     Returns the length of the shortest contiguous subarray
      in nums whose sum is at least target.
 
-    Args:
-        target (int): The minimum sum that the subarray should have.
-        nums (list[int]): The array to search for subarrays in.
-
-    Returns:
-        int: The length of the shortest contiguous subarray
-        in nums whose sum is at least target. If no such subarray exists, returns 0.
-
     Examples:
         >>> minsubarraysum(7, [2, 3, 1, 2, 4, 3])
         2
+        >>> minsubarraysum(7, [2, 3, -1, 2, 4, -3])
+        4
+        >>> minsubarraysum(11, [1, 1, 1, 1, 1, 1, 1, 1])
+        0
     """
     n = len(nums)
     if n == 0:

From dfd660cfd086ad3a5206690cc0aaa869947f157a Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Thu, 30 Mar 2023 09:03:59 +0530
Subject: [PATCH 14/41] Rename sliding_window/minimum_size_subarray_sum.py to
 dynamic_programming/minimum_size_subarray_sum.py

---
 .../minimum_size_subarray_sum.py                                  | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename {sliding_window => dynamic_programming}/minimum_size_subarray_sum.py (100%)

diff --git a/sliding_window/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
similarity index 100%
rename from sliding_window/minimum_size_subarray_sum.py
rename to dynamic_programming/minimum_size_subarray_sum.py

From 4bc8033d91be31207dc3b593094de1d6dcb0dcd7 Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Thu, 30 Mar 2023 09:39:28 +0530
Subject: [PATCH 15/41] Update minimum_size_subarray_sum.py

---
 dynamic_programming/minimum_size_subarray_sum.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index 80664e2c751b..65cf63ab7ad6 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -27,5 +27,5 @@ def minsubarraysum(target: int, nums: list[int]) -> int:
             curr_sum -= nums[left]
             left += 1
         right += 1
-
+        
     return int(min_len) if min_len != float("inf") else 0

From 7476e78c8032faabe56ddf1e58ddce842c774a2e Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 30 Mar 2023 04:11:06 +0000
Subject: [PATCH 16/41] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 dynamic_programming/minimum_size_subarray_sum.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index 65cf63ab7ad6..80664e2c751b 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -27,5 +27,5 @@ def minsubarraysum(target: int, nums: list[int]) -> int:
             curr_sum -= nums[left]
             left += 1
         right += 1
-        
+
     return int(min_len) if min_len != float("inf") else 0

From 5098fbf948c9129dedc44081ea3b72bc0732d73d Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Thu, 30 Mar 2023 10:28:34 +0530
Subject: [PATCH 17/41] Update minimum_size_subarray_sum.py

---
 dynamic_programming/minimum_size_subarray_sum.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index 80664e2c751b..2592b3b48402 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -3,7 +3,7 @@ def minsubarraysum(target: int, nums: list[int]) -> int:
     Returns the length of the shortest contiguous subarray
      in nums whose sum is at least target.
 
-    Examples:
+    Examples :
         >>> minsubarraysum(7, [2, 3, 1, 2, 4, 3])
         2
         >>> minsubarraysum(7, [2, 3, -1, 2, 4, -3])

From a266d4e2b63b4b73f0d162a8679b9539cd254960 Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Thu, 30 Mar 2023 12:09:35 +0530
Subject: [PATCH 18/41] Update minimum_size_subarray_sum.py

---
 dynamic_programming/minimum_size_subarray_sum.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index 2592b3b48402..0295deb23e79 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -1,4 +1,4 @@
-def minsubarraysum(target: int, nums: list[int]) -> int:
+def minsubarraysum(target: int, numbers: list[int]) -> int:
     """
     Returns the length of the shortest contiguous subarray
      in nums whose sum is at least target.
@@ -11,7 +11,7 @@ def minsubarraysum(target: int, nums: list[int]) -> int:
         >>> minsubarraysum(11, [1, 1, 1, 1, 1, 1, 1, 1])
         0
     """
-    n = len(nums)
+    n = len(numbers)
     if n == 0:
         return 0
 
@@ -21,10 +21,10 @@ def minsubarraysum(target: int, nums: list[int]) -> int:
     min_len = float("inf")
 
     while right < n:
-        curr_sum += nums[right]
+        curr_sum += numbers[right]
         while curr_sum >= target:
             min_len = min(min_len, right - left + 1)
-            curr_sum -= nums[left]
+            curr_sum -= numbers[left]
             left += 1
         right += 1
 

From 55f08824fbdc6e98f31921244dd97177c0232de7 Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Fri, 31 Mar 2023 16:59:01 +0530
Subject: [PATCH 19/41] Update minimum_size_subarray_sum.py

---
 dynamic_programming/minimum_size_subarray_sum.py | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index 0295deb23e79..377925afe3cc 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -11,13 +11,11 @@ def minsubarraysum(target: int, numbers: list[int]) -> int:
         >>> minsubarraysum(11, [1, 1, 1, 1, 1, 1, 1, 1])
         0
     """
-    n = len(numbers)
-    if n == 0:
+
+    if len(numbers) == 0:
         return 0
 
-    left = 0
-    right = 0
-    curr_sum = 0
+    left = right = curr_sum = 0
     min_len = float("inf")
 
     while right < n:

From b111c317c6ccb1a4e2f660a34a595211e4bc22b7 Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Fri, 31 Mar 2023 17:02:02 +0530
Subject: [PATCH 20/41] Update minimum_size_subarray_sum.py

---
 dynamic_programming/minimum_size_subarray_sum.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index 377925afe3cc..2e10d52e0116 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -18,7 +18,7 @@ def minsubarraysum(target: int, numbers: list[int]) -> int:
     left = right = curr_sum = 0
     min_len = float("inf")
 
-    while right < n:
+    while right < len(numbers):
         curr_sum += numbers[right]
         while curr_sum >= target:
             min_len = min(min_len, right - left + 1)

From 35b2ff29b32defd10eb06c4b57664526fbb360b5 Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Sat, 1 Apr 2023 11:33:59 +0530
Subject: [PATCH 21/41] Update minimum_size_subarray_sum.py

---
 dynamic_programming/minimum_size_subarray_sum.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index 2e10d52e0116..cbd7f4f30f13 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -10,6 +10,16 @@ def minsubarraysum(target: int, numbers: list[int]) -> int:
         4
         >>> minsubarraysum(11, [1, 1, 1, 1, 1, 1, 1, 1])
         0
+        >>> minsubarraysum(10, [1, 2, 3, 4, 5, 6, 7])
+        4
+        >>> minsubarraysum(5, [1, 1, 1, 1, 1, 5])
+        1
+        >>> minsubarraysum(0, [])
+        0
+        >>> minsubarraysum(10, [10, 20, 30])
+        1
+        >>> minsubarraysum(7, [1, 1, 1, 1, 1, 1, 10])
+        1
     """
 
     if len(numbers) == 0:

From f8c2d67bd45b9b2a1e72f26675ffd006d3754065 Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Sat, 1 Apr 2023 12:10:59 +0530
Subject: [PATCH 22/41] Update minimum_size_subarray_sum.py

---
 dynamic_programming/minimum_size_subarray_sum.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index cbd7f4f30f13..07e9594983b6 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -11,7 +11,7 @@ def minsubarraysum(target: int, numbers: list[int]) -> int:
         >>> minsubarraysum(11, [1, 1, 1, 1, 1, 1, 1, 1])
         0
         >>> minsubarraysum(10, [1, 2, 3, 4, 5, 6, 7])
-        4
+        2
         >>> minsubarraysum(5, [1, 1, 1, 1, 1, 5])
         1
         >>> minsubarraysum(0, [])

From 58906118d4fa27a5a02a0dab5d39bb1a3435c2d4 Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Sat, 1 Apr 2023 19:47:00 +0530
Subject: [PATCH 23/41] Update dynamic_programming/minimum_size_subarray_sum.py

Co-authored-by: Christian Clauss <cclauss@me.com>
---
 dynamic_programming/minimum_size_subarray_sum.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index 07e9594983b6..80f6a8136018 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -3,7 +3,6 @@ def minsubarraysum(target: int, numbers: list[int]) -> int:
     Returns the length of the shortest contiguous subarray
      in nums whose sum is at least target.
 
-    Examples :
         >>> minsubarraysum(7, [2, 3, 1, 2, 4, 3])
         2
         >>> minsubarraysum(7, [2, 3, -1, 2, 4, -3])

From 615854f0e7a459c822750e8d0fc671babe70cbdb Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Sat, 1 Apr 2023 19:47:24 +0530
Subject: [PATCH 24/41] Update dynamic_programming/minimum_size_subarray_sum.py

Co-authored-by: Christian Clauss <cclauss@me.com>
---
 dynamic_programming/minimum_size_subarray_sum.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index 80f6a8136018..26de290c7941 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -21,9 +21,8 @@ def minsubarraysum(target: int, numbers: list[int]) -> int:
         1
     """
 
-    if len(numbers) == 0:
+    if not numbers:
         return 0
-
     left = right = curr_sum = 0
     min_len = float("inf")
 

From 254f88e6806d780ed2ff08850bf3c1a6a3ba4d8f Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Sat, 1 Apr 2023 19:48:11 +0530
Subject: [PATCH 25/41] Update dynamic_programming/minimum_size_subarray_sum.py

Co-authored-by: Christian Clauss <cclauss@me.com>
---
 dynamic_programming/minimum_size_subarray_sum.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index 26de290c7941..8a3b6671e181 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -24,7 +24,7 @@ def minsubarraysum(target: int, numbers: list[int]) -> int:
     if not numbers:
         return 0
     left = right = curr_sum = 0
-    min_len = float("inf")
+    min_len = sys.maxsize
 
     while right < len(numbers):
         curr_sum += numbers[right]

From 695605ca19752d2013bd315265232f781ee1df4c Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Sat, 1 Apr 2023 19:48:31 +0530
Subject: [PATCH 26/41] Update dynamic_programming/minimum_size_subarray_sum.py

Co-authored-by: Christian Clauss <cclauss@me.com>
---
 dynamic_programming/minimum_size_subarray_sum.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index 8a3b6671e181..97f684ec556d 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -26,12 +26,11 @@ def minsubarraysum(target: int, numbers: list[int]) -> int:
     left = right = curr_sum = 0
     min_len = sys.maxsize
 
-    while right < len(numbers):
-        curr_sum += numbers[right]
+    for right, number in enumerate(numbers):
+        curr_sum += number
         while curr_sum >= target:
             min_len = min(min_len, right - left + 1)
             curr_sum -= numbers[left]
             left += 1
-        right += 1
 
     return int(min_len) if min_len != float("inf") else 0

From 5e5f5289d0a7463b8a745860e3a56667e8ea9f48 Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Sat, 1 Apr 2023 19:48:40 +0530
Subject: [PATCH 27/41] Update dynamic_programming/minimum_size_subarray_sum.py

Co-authored-by: Christian Clauss <cclauss@me.com>
---
 dynamic_programming/minimum_size_subarray_sum.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index 97f684ec556d..ac01a33f5552 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -33,4 +33,4 @@ def minsubarraysum(target: int, numbers: list[int]) -> int:
             curr_sum -= numbers[left]
             left += 1
 
-    return int(min_len) if min_len != float("inf") else 0
+    return 0 if min_len == sys.maxsize else min_len

From 57e5e37b2005b245ad0787be2fe57c5980e3d66a Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Sat, 1 Apr 2023 19:48:57 +0530
Subject: [PATCH 28/41] Update dynamic_programming/minimum_size_subarray_sum.py

Co-authored-by: Christian Clauss <cclauss@me.com>
---
 dynamic_programming/minimum_size_subarray_sum.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index ac01a33f5552..bb0a9cbbb9cf 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -1,7 +1,7 @@
 def minsubarraysum(target: int, numbers: list[int]) -> int:
     """
     Returns the length of the shortest contiguous subarray
-     in nums whose sum is at least target.
+     in a list of numbers whose sum is at least target.
 
         >>> minsubarraysum(7, [2, 3, 1, 2, 4, 3])
         2

From f00d0718e05739198b88e788a76add6fbaaa636f Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Sat, 1 Apr 2023 19:49:04 +0530
Subject: [PATCH 29/41] Update dynamic_programming/minimum_size_subarray_sum.py

Co-authored-by: Christian Clauss <cclauss@me.com>
---
 dynamic_programming/minimum_size_subarray_sum.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index bb0a9cbbb9cf..ed95a797bc31 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -1,4 +1,4 @@
-def minsubarraysum(target: int, numbers: list[int]) -> int:
+def minimum_subarray_sum(target: int, numbers: list[int]) -> int:
     """
     Returns the length of the shortest contiguous subarray
      in a list of numbers whose sum is at least target.

From 34eefadb51c51a0013ffe0f989a0689dc7d0bc44 Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Sat, 1 Apr 2023 20:05:49 +0530
Subject: [PATCH 30/41] Update minimum_size_subarray_sum.py

---
 .../minimum_size_subarray_sum.py              | 35 ++++++++++++++-----
 1 file changed, 26 insertions(+), 9 deletions(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index ed95a797bc31..9eb4f8fbd818 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -1,28 +1,45 @@
+import sys
+
 def minimum_subarray_sum(target: int, numbers: list[int]) -> int:
     """
     Returns the length of the shortest contiguous subarray
      in a list of numbers whose sum is at least target.
-
-        >>> minsubarraysum(7, [2, 3, 1, 2, 4, 3])
+        >>> minimum_subarray_sum(7, [2, 3, 1, 2, 4, 3])
         2
-        >>> minsubarraysum(7, [2, 3, -1, 2, 4, -3])
+        >>> minimum_subarray_sum(7, [2, 3, -1, 2, 4, -3])
         4
-        >>> minsubarraysum(11, [1, 1, 1, 1, 1, 1, 1, 1])
+        >>> minimum_subarray_sum(11, [1, 1, 1, 1, 1, 1, 1, 1])
         0
-        >>> minsubarraysum(10, [1, 2, 3, 4, 5, 6, 7])
+        >>> minimum_subarray_sum(10, [1, 2, 3, 4, 5, 6, 7])
         2
-        >>> minsubarraysum(5, [1, 1, 1, 1, 1, 5])
+        >>> minimum_subarray_sum(5, [1, 1, 1, 1, 1, 5])
         1
-        >>> minsubarraysum(0, [])
+        >>> minimum_subarray_sum(0, [])
         0
-        >>> minsubarraysum(10, [10, 20, 30])
+        >>> minimum_subarray_sum(10, [10, 20, 30])
+        1
+        >>> minimum_subarray_sum(7, [1, 1, 1, 1, 1, 1, 10])
         1
-        >>> minsubarraysum(7, [1, 1, 1, 1, 1, 1, 10])
+        >>> minimum_subarray_sum(6, [])
+        0
+        >>> minimum_subarray_sum(2, [1, 2, 3])
         1
+        >>> minimum_subarray_sum(-6, [])
+        0
+        >>> minimum_subarray_sum(8, None)
+        0
+        >>> minimum_subarray_sum(2, "ABC")
+        Traceback (most recent call last):
+        ...
+        ValueError: numbers must be an iterable of integers
     """
 
     if not numbers:
         return 0
+    if not isinstance(numbers, (list, tuple)) or not all(
+            isinstance(number, int) for number in numbers
+    ):
+        raise ValueError("numbers must be an iterable of integers")
     left = right = curr_sum = 0
     min_len = sys.maxsize
 

From 92e264028e25b96cf6c2e3c368356d9fbdde3eb1 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Sat, 1 Apr 2023 14:36:19 +0000
Subject: [PATCH 31/41] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 dynamic_programming/minimum_size_subarray_sum.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index 9eb4f8fbd818..219d65efe98b 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -1,5 +1,6 @@
 import sys
 
+
 def minimum_subarray_sum(target: int, numbers: list[int]) -> int:
     """
     Returns the length of the shortest contiguous subarray
@@ -37,7 +38,7 @@ def minimum_subarray_sum(target: int, numbers: list[int]) -> int:
     if not numbers:
         return 0
     if not isinstance(numbers, (list, tuple)) or not all(
-            isinstance(number, int) for number in numbers
+        isinstance(number, int) for number in numbers
     ):
         raise ValueError("numbers must be an iterable of integers")
     left = right = curr_sum = 0

From d65430e65619226fd362a634b5457d4e77eebb5c Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Sat, 1 Apr 2023 17:08:43 +0200
Subject: [PATCH 32/41] Fix

---
 .../minimum_size_subarray_sum.py              | 67 +++++++++++--------
 1 file changed, 39 insertions(+), 28 deletions(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index 219d65efe98b..6b2f56e83886 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -5,34 +5,39 @@ def minimum_subarray_sum(target: int, numbers: list[int]) -> int:
     """
     Returns the length of the shortest contiguous subarray
      in a list of numbers whose sum is at least target.
-        >>> minimum_subarray_sum(7, [2, 3, 1, 2, 4, 3])
-        2
-        >>> minimum_subarray_sum(7, [2, 3, -1, 2, 4, -3])
-        4
-        >>> minimum_subarray_sum(11, [1, 1, 1, 1, 1, 1, 1, 1])
-        0
-        >>> minimum_subarray_sum(10, [1, 2, 3, 4, 5, 6, 7])
-        2
-        >>> minimum_subarray_sum(5, [1, 1, 1, 1, 1, 5])
-        1
-        >>> minimum_subarray_sum(0, [])
-        0
-        >>> minimum_subarray_sum(10, [10, 20, 30])
-        1
-        >>> minimum_subarray_sum(7, [1, 1, 1, 1, 1, 1, 10])
-        1
-        >>> minimum_subarray_sum(6, [])
-        0
-        >>> minimum_subarray_sum(2, [1, 2, 3])
-        1
-        >>> minimum_subarray_sum(-6, [])
-        0
-        >>> minimum_subarray_sum(8, None)
-        0
-        >>> minimum_subarray_sum(2, "ABC")
-        Traceback (most recent call last):
+     
+    >>> minimum_subarray_sum(7, [2, 3, 1, 2, 4, 3])
+    2
+    >>> minimum_subarray_sum(7, [2, 3, -1, 2, 4, -3])
+    4
+    >>> minimum_subarray_sum(11, [1, 1, 1, 1, 1, 1, 1, 1])
+    0
+    >>> minimum_subarray_sum(10, [1, 2, 3, 4, 5, 6, 7])
+    2
+    >>> minimum_subarray_sum(5, [1, 1, 1, 1, 1, 5])
+    1
+    >>> minimum_subarray_sum(0, [])
+    0
+    >>> minimum_subarray_sum(0, [1, 2, 3])
+    0
+    >>> minimum_subarray_sum(10, [10, 20, 30])
+    1
+    >>> minimum_subarray_sum(7, [1, 1, 1, 1, 1, 1, 10])
+    1
+    >>> minimum_subarray_sum(6, [])
+    0
+    >>> minimum_subarray_sum(2, [1, 2, 3])
+    1
+    >>> minimum_subarray_sum(-6, [])
+    0
+    >>> minimum_subarray_sum(-6, [3, 4, 5])
+    0
+    >>> minimum_subarray_sum(8, None)
+    0
+    >>> minimum_subarray_sum(2, "ABC")
+    Traceback (most recent call last):
         ...
-        ValueError: numbers must be an iterable of integers
+    ValueError: numbers must be an iterable of integers
     """
 
     if not numbers:
@@ -41,9 +46,9 @@ def minimum_subarray_sum(target: int, numbers: list[int]) -> int:
         isinstance(number, int) for number in numbers
     ):
         raise ValueError("numbers must be an iterable of integers")
+
     left = right = curr_sum = 0
     min_len = sys.maxsize
-
     for right, number in enumerate(numbers):
         curr_sum += number
         while curr_sum >= target:
@@ -52,3 +57,9 @@ def minimum_subarray_sum(target: int, numbers: list[int]) -> int:
             left += 1
 
     return 0 if min_len == sys.maxsize else min_len
+
+
+if __name__ == "__main__":
+    from doctest import testmod
+    
+    testmod()()

From c20a5b184f897002115cf58808c21b4cd914d7d3 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Sat, 1 Apr 2023 15:09:15 +0000
Subject: [PATCH 33/41] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 dynamic_programming/minimum_size_subarray_sum.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index 6b2f56e83886..ef5465e4d8f9 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -5,7 +5,7 @@ def minimum_subarray_sum(target: int, numbers: list[int]) -> int:
     """
     Returns the length of the shortest contiguous subarray
      in a list of numbers whose sum is at least target.
-     
+
     >>> minimum_subarray_sum(7, [2, 3, 1, 2, 4, 3])
     2
     >>> minimum_subarray_sum(7, [2, 3, -1, 2, 4, -3])
@@ -61,5 +61,5 @@ def minimum_subarray_sum(target: int, numbers: list[int]) -> int:
 
 if __name__ == "__main__":
     from doctest import testmod
-    
+
     testmod()()

From c88303d3145e01437b4522d25c4814f5d70520d8 Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Sat, 1 Apr 2023 22:13:14 +0530
Subject: [PATCH 34/41] Update minimum_size_subarray_sum.py

---
 dynamic_programming/minimum_size_subarray_sum.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index ef5465e4d8f9..6f1e296c86a5 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -59,7 +59,4 @@ def minimum_subarray_sum(target: int, numbers: list[int]) -> int:
     return 0 if min_len == sys.maxsize else min_len
 
 
-if __name__ == "__main__":
-    from doctest import testmod
 
-    testmod()()

From 2c699344b11098de3ec2ee2b417c2bc3f42f81dc Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Sat, 1 Apr 2023 16:43:59 +0000
Subject: [PATCH 35/41] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 dynamic_programming/minimum_size_subarray_sum.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index 6f1e296c86a5..3407aa1a1b65 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -57,6 +57,3 @@ def minimum_subarray_sum(target: int, numbers: list[int]) -> int:
             left += 1
 
     return 0 if min_len == sys.maxsize else min_len
-
-
-

From ae1996c167fc7690033d3afd0089100c2804a85d Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Sat, 1 Apr 2023 23:13:23 +0530
Subject: [PATCH 36/41] Update minimum_size_subarray_sum.py

---
 dynamic_programming/minimum_size_subarray_sum.py | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index 3407aa1a1b65..3801f6b92f8e 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -39,9 +39,10 @@ def minimum_subarray_sum(target: int, numbers: list[int]) -> int:
         ...
     ValueError: numbers must be an iterable of integers
     """
-
     if not numbers:
         return 0
+    if target == 0 and target in numbers:
+        return 0
     if not isinstance(numbers, (list, tuple)) or not all(
         isinstance(number, int) for number in numbers
     ):
@@ -49,11 +50,13 @@ def minimum_subarray_sum(target: int, numbers: list[int]) -> int:
 
     left = right = curr_sum = 0
     min_len = sys.maxsize
-    for right, number in enumerate(numbers):
-        curr_sum += number
-        while curr_sum >= target:
+    
+    while right < len(numbers):
+        curr_sum += numbers[right]
+        while curr_sum >= target and left <= right:
             min_len = min(min_len, right - left + 1)
             curr_sum -= numbers[left]
             left += 1
+        right += 1
 
     return 0 if min_len == sys.maxsize else min_len

From 823287e8bcbd913f9509bdbee254ae4181739f24 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Sat, 1 Apr 2023 17:44:03 +0000
Subject: [PATCH 37/41] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 dynamic_programming/minimum_size_subarray_sum.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index 3801f6b92f8e..d93c33b00558 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -50,7 +50,7 @@ def minimum_subarray_sum(target: int, numbers: list[int]) -> int:
 
     left = right = curr_sum = 0
     min_len = sys.maxsize
-    
+
     while right < len(numbers):
         curr_sum += numbers[right]
         while curr_sum >= target and left <= right:

From 36d09a02defaa5aa47bba57753ceb2ad32e8c6eb Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Sun, 2 Apr 2023 23:45:45 +0530
Subject: [PATCH 38/41] Update minimum_size_subarray_sum.py

---
 dynamic_programming/minimum_size_subarray_sum.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index d93c33b00558..f15bd2ac7e04 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -19,7 +19,7 @@ def minimum_subarray_sum(target: int, numbers: list[int]) -> int:
     >>> minimum_subarray_sum(0, [])
     0
     >>> minimum_subarray_sum(0, [1, 2, 3])
-    0
+    1
     >>> minimum_subarray_sum(10, [10, 20, 30])
     1
     >>> minimum_subarray_sum(7, [1, 1, 1, 1, 1, 1, 10])
@@ -31,7 +31,7 @@ def minimum_subarray_sum(target: int, numbers: list[int]) -> int:
     >>> minimum_subarray_sum(-6, [])
     0
     >>> minimum_subarray_sum(-6, [3, 4, 5])
-    0
+    1
     >>> minimum_subarray_sum(8, None)
     0
     >>> minimum_subarray_sum(2, "ABC")

From d3cd16255a6a41aea5b8d600afd6d788fdbb88c6 Mon Sep 17 00:00:00 2001
From: Rohan Anand <96521078+rohan472000@users.noreply.github.com>
Date: Tue, 18 Apr 2023 13:20:02 +0530
Subject: [PATCH 39/41] Update minimum_size_subarray_sum.py

---
 dynamic_programming/minimum_size_subarray_sum.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index f15bd2ac7e04..2416ed5d9e77 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -6,6 +6,8 @@ def minimum_subarray_sum(target: int, numbers: list[int]) -> int:
     Returns the length of the shortest contiguous subarray
      in a list of numbers whose sum is at least target.
 
+    Reference: https://stackoverflow.com/questions/8269916/what-is-sliding-window-algorithm-examples
+    
     >>> minimum_subarray_sum(7, [2, 3, 1, 2, 4, 3])
     2
     >>> minimum_subarray_sum(7, [2, 3, -1, 2, 4, -3])

From b67b6f75d3c9f3ff3570297710a3b90909919b80 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 18 Apr 2023 07:50:36 +0000
Subject: [PATCH 40/41] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 dynamic_programming/minimum_size_subarray_sum.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index 2416ed5d9e77..80d8f9218a8d 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -7,7 +7,7 @@ def minimum_subarray_sum(target: int, numbers: list[int]) -> int:
      in a list of numbers whose sum is at least target.
 
     Reference: https://stackoverflow.com/questions/8269916/what-is-sliding-window-algorithm-examples
-    
+
     >>> minimum_subarray_sum(7, [2, 3, 1, 2, 4, 3])
     2
     >>> minimum_subarray_sum(7, [2, 3, -1, 2, 4, -3])

From 1e189582e4a1ecd32fa338821fc81e6932613777 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Tue, 18 Apr 2023 10:01:48 +0200
Subject: [PATCH 41/41] Update minimum_size_subarray_sum.py

---
 dynamic_programming/minimum_size_subarray_sum.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/dynamic_programming/minimum_size_subarray_sum.py b/dynamic_programming/minimum_size_subarray_sum.py
index 80d8f9218a8d..3868d73535fb 100644
--- a/dynamic_programming/minimum_size_subarray_sum.py
+++ b/dynamic_programming/minimum_size_subarray_sum.py
@@ -3,10 +3,8 @@
 
 def minimum_subarray_sum(target: int, numbers: list[int]) -> int:
     """
-    Returns the length of the shortest contiguous subarray
-     in a list of numbers whose sum is at least target.
-
-    Reference: https://stackoverflow.com/questions/8269916/what-is-sliding-window-algorithm-examples
+    Return the length of the shortest contiguous subarray in a list of numbers whose sum
+    is at least target.  Reference: https://stackoverflow.com/questions/8269916
 
     >>> minimum_subarray_sum(7, [2, 3, 1, 2, 4, 3])
     2