Add min subarray sum

Author: sudheerj

src/java1/algorithms/array/minimumSizeSubarraySum/MinimumSizeSubarraySum.java

@@ -0,0 +1,35 @@
+// Sliding window: TC: O(n), SC: O(1)
+package minimumSizeSubarraySum;
+
+public class MinimumSizeSubarraySum {
+
+    private static int minSizeSubarraySum(int[] nums, int target) {
+        int left = 0, right = 0, total = 0, result = Integer.MAX_VALUE;
+
+        while(right < nums.length) {
+            total += nums[right];
+            while(total >= target) {
+                result = Math.min(right-left+1, result);
+                total -= nums[left++];
+            }
+            right++;
+        }
+
+        return result == Integer.MAX_VALUE ? 0 : result;
+
+    }
+
+    public static void main(String[] args) {
+
+        int target1 = 7;
+        int[] nums1 = {2,4,1,2,4,3};
+        int target2 = 5;
+        int[] nums2 = {1, 5, 5, 5};
+        int target3 = 15;
+        int[] nums3 = {2, 2, 2, 2, 2};
+        
+        System.out.println(minSizeSubarraySum(nums1, target1));
+        System.out.println(minSizeSubarraySum(nums2, target2));
+        System.out.println(minSizeSubarraySum(nums3, target3));
+    }
+}

src/java1/algorithms/array/minimumSizeSubarraySum/MinimumSizeSubarraySum.md

@@ -0,0 +1,23 @@
+**Algorithmic Steps**
+This problem is solved with the help of sliding window approach without using any special data structure. The algorithmic approach can be summarized as follows:
+
+1. Initialize left and right pointers to 0, to keep track of the substring window boundaries.
+
+2. Initialize total variable to 0, to store the sum of the subarray values to meet the target criteria.
+
+3. Initialize result variable to max integer value to indicate that there is no subarray to meet target value.
+
+4. Iterate over the input array using right pointer until the end of the string. 
+
+5. Calculate the total value by adding array value at respective right pointer.
+
+6. If the total value is greather or equal to target, find the minimum of subarray sum and shrink the current window total and left pointer value. This step need to be repeated until there are no subarray exists to meet the target criteria.
+
+7. Increment the right pointer to find the next subarray.
+
+8. Repeat steps 4–7 until the right pointer reaches the end of the array.
+
+9. Return 0 if the result is still a maximum integer which indicates no valid subarray otherwise return the calculated minimum subarray value.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of O(n) because we are traversing the array only twice at max. Since it doens't require any datastructure, the space complexity will be O(1).

src/java1/algorithms/strings/longestSubstringWithoutRepeatingChar.java src/java1/algorithms/strings/longestSubstringWithoutRepeatingChars/LongestSubstringWithoutRepeatingChars.java

@@ -1,19 +1,22 @@
 // Sliding window: TC: O(n), SC: O(n)
-package java1.algorithms.strings;
+package java1.algorithms.strings.longestSubstringWithoutRepeatingChars;
 
 import java.util.HashSet;
 
-public class LongestSubstringWithoutRepeatingChar {
+public class LongestSubstringWithoutRepeatingChars {
+
     private static int longestSubstringLengthWithoutRepeatingChar(String str) {
+        
         HashSet<Character> hashset = new HashSet<>();
-        int left = 0, max = 0;
+        int left = 0, right = 0, max = 0;
 
-        for(int right = 0; right < str.length(); right++) {
+        while(right < str.length()) {
             while(hashset.contains(str.charAt(right))){
                 hashset.remove(str.charAt(left));
                 left++;
             }
             hashset.add(str.charAt(right));
+            right++;
             max = Math.max(max, hashset.size());
         }
         return max;
@@ -22,6 +25,7 @@ private static int longestSubstringLengthWithoutRepeatingChar(String str) {
     public static void main(String[] args) {
         String string1 = "abcabcbbaa";
         System.out.println(longestSubstringLengthWithoutRepeatingChar(string1));
+        
         String string2 = "aaaaaaa";
         System.out.println(longestSubstringLengthWithoutRepeatingChar(string2));
     }

src/java1/algorithms/strings/longestSubstringWithoutRepeatingChars/LongestSubstringWithoutRepeatingChars.md

@@ -0,0 +1,23 @@
+**Algorithmic Steps**
+This problem is solved with the help of sliding window approach using a HashSet. The algorithmic approach can be summarized as follows:
+
+1. Initialize an empty HashSet to store unique characters within the current window.
+
+2. Initialize left and right pointers to 0, to keep track of the substring window boundaries.
+
+3. Initialize maxLength variable to 0, to store the length of the longest substring without repeating characters.
+
+4. Iterate over the input string using right pointer until the end of the string. 
+
+5. If a repeating character is found, remove the repeated character from the char set and move the left pointer to the right(i.e, increment left pointer) to shrink the window. This step need to be repeated until there is no repeated character in the set.
+
+6. If the new character doesn't exist in the char set, add the character to the set and move the right pointer(i.e, increment right pointer) to expand the window.
+
+7. Update the maxLength variable if the current window length is greater than the previous maxLength.
+
+8. Repeat steps 4–7 until the right pointer reaches the end of the string.
+
+9. Return the maxLength variable which indicates the longest substring length.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of O(n) because we are traversing the string only once. Also, it requires space complexity of O(n) due to HashSet data structure.

src/javascript/algorithms/array/minimumSizeSubarraySum/minSizeSubarraySum.js

@@ -0,0 +1,27 @@
+// Sliding window: TC: O(n), SC: O(1)
+
+function minSizeSubarraySum(nums, target) {
+    
+    let left = right = total = 0;
+    let result = Infinity;
+
+    while(right < nums.length) {
+        total += nums[right];
+        while(total >= target) {
+            result = Math.min(right - left + 1, result);
+            total -= nums[left++];
+        }
+        right++;
+    }
+
+    return result === Infinity ? 0 : result;
+}
+
+let target1 = 7, nums1 = [2,4,1,2,4,3];
+let target2 = 5, nums2 = [1, 5, 5, 5];
+let target3 = 15, nums3 = [2, 2, 2, 2, 2];
+
+console.log(minSizeSubarraySum(nums1, target1));
+console.log(minSizeSubarraySum(nums2, target2));
+console.log(minSizeSubarraySum(nums3, target3));
+

src/javascript/algorithms/array/minimumSizeSubarraySum/minSizeSubarraySum.md

@@ -0,0 +1,23 @@
+**Algorithmic Steps**
+This problem is solved with the help of sliding window approach without using any special data structure. The algorithmic approach can be summarized as follows:
+
+1. Initialize left and right pointers to 0, to keep track of the substring window boundaries.
+
+2. Initialize total variable to 0, to store the sum of the subarray values to meet the target criteria.
+
+3. Initialize result variable to infinity to indicate that there is no subarray to meet target value.
+
+4. Iterate over the input array using right pointer until the end of the string. 
+
+5. Calculate the total value by adding array value at respective right pointer.
+
+6. If the total value is greather or equal to target, find the minimum of subarray sum and shrink the current window total and left pointer value. This step need to be repeated until there are no subarray exists to meet the target criteria.
+
+7. Increment the right pointer to find the next subarray.
+
+8. Repeat steps 4–7 until the right pointer reaches the end of the array.
+
+9. Return 0 if the result is still an infinity which indicates no valid subarray otherwise return the calculated minimum subarray value.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of O(n) because we are traversing the array only twice at max. Since it doens't require any datastructure, the space complexity will be O(1).

src/javascript/algorithms/strings/LongestSubstringWithoutRepeatingChars/longestSubstringWithoutRepeatingChars.js

@@ -1,17 +1,17 @@
 // Sliding window: TC: O(n), SC: O(n)
 function longestSubstringLengthWithoutRepeatingChar(string) {
 
-    let set = new Set();
+    let charSet = new Set();
     let left = right = maxLength = 0;
 
     while(right < string.length) {
-        while(set.has(string[right])) {
-            set.delete(string[left]);
+        while(charSet.has(string[right])) {
+            charSet.delete(string[left]);
             left++;
         }
-        set.add(string[right]);
+        charSet.add(string[right]);
         right++;
-        maxLength = Math.max(maxLength, set.size); 
+        maxLength = Math.max(maxLength, charSet.size); 
     }
     return maxLength;
 }