Update minimum window substring problem

Author: sudheerj

README.md

@@ -84,7 +84,7 @@ List of Programs related to data structures and algorithms
 
    2. Longest repeating character replacement: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/2.longestRepeatingCharReplacement/longestRepeatingCharReplacement.js) [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/2.longestRepeatingCharReplacement/longestRepeatingCharReplacement.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/2.longestRepeatingCharReplacement/longestRepeatingCharReplacement.md)
 
-   3. Minimum window substring: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/minWindowSubstring/minWindowSubstring.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/minWindowSubstring/minWindowSubstring.md)
+   3. Minimum window substring: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/3.minWindowSubstring/minWindowSubstring.js)  [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/3.minWindowSubstring/minWindowSubstring.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/3.minWindowSubstring/minWindowSubstring.md)
 
    4. Valid anagram: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/validAnagram.js)
 

src/java1/algorithms/strings/minWindowSubstring/MinWindowSubstring.java

@@ -1,5 +1,5 @@
 package java1.algorithms.strings.minWindowSubstring;
-// Sliding window: TC: O(m) + O(n) SC: O(m) + O(n)
+// Sliding window: TC: O(m) + O(n), SC: O(m) + O(n)
 
 import java.util.HashMap;
 
@@ -13,10 +13,9 @@ private static String minWindowSubstring(String windowStr, String subStr) {
         HashMap<Character, Integer> windowStrCount = new HashMap<>();
 
         int minLength = Integer.MAX_VALUE;
-        int leftIndex = -1, rightIndex = -1;
+        int[] subStrBoundaries = new int[]{-1, -1};
 
-        for(int i=0; i< subStr.length(); i++) {
-            char ch = subStr.charAt(i);
+        for(char ch: subStr.toCharArray()) {
             subStrCount.put(ch, subStrCount.getOrDefault(ch, 0) + 1);
         }
 
@@ -27,34 +26,30 @@ private static String minWindowSubstring(String windowStr, String subStr) {
 
             if(subStrCount.containsKey(rightChar)) {
                 windowStrCount.put(rightChar, windowStrCount.getOrDefault(rightChar, 0) + 1);
-                if(subStrCount.get(rightChar).intValue() == windowStrCount.get(rightChar).intValue()) {
+                if(subStrCount.get(rightChar) == windowStrCount.get(rightChar)) {
                     having++;
                 } 
             }
 
             while(required == having) {
                 if(minLength > right-left+1) {
                     minLength = right-left+1;
-                    leftIndex = left;
-                    rightIndex = right;
+                    subStrBoundaries[0] = left;
+                    subStrBoundaries[1] = right;
                 }
+                
                 char leftChar = windowStr.charAt(left);
-
                 if(subStrCount.containsKey(leftChar)) {
                     windowStrCount.put(leftChar, windowStrCount.get(leftChar)-1);
-                    if(windowStrCount.get(leftChar).intValue() < subStrCount.get(leftChar).intValue()) {
+                    if(windowStrCount.get(leftChar) < subStrCount.get(leftChar)) {
                         having--;
                     }
                 }
                 left++;
             }
         }
-        if(leftIndex == -1 || rightIndex == -1) {
-            return "";
-        } else {
-            return windowStr.substring(leftIndex, rightIndex+1);
-        }
 
+        return minLength == Integer.MAX_VALUE ? "" : windowStr.substring(subStrBoundaries[0], subStrBoundaries[1]+1);
     }
 
     public static void main(String[] args) {

src/java1/algorithms/strings/minWindowSubstring/MinWindowSubstring.md

@@ -1,30 +1,51 @@
+**Description:**
+Given two strings `str` and `subStr` of lengths `m` and `n` respectively, return the minimum window 
+substring of `str` such that every character in `subStr` (including duplicates) is included in the window. If there is no such substring available, just return the empty string(i.e,"").
+
+### Examples
+Example 1:
+
+Input: str = "ADOBECODEBANC", subStr = "ABC"
+Output: "BANC"
+Explanation: The minimum window substring "BANC" includes 'A', 'B', and 'C' from string t.
+
+Example 2:
+Input: str = "A", subStr = "A"
+Output: "A"
+
+Example 3:
+Input: str = "a", subStr = "aa"
+Output: ""
+
 **Algorithmic Steps**
-This problem is solved with the help of sliding window approach using two hash maps. The algorithmic approach can be summarized as follows:
+This problem is solved with the help of **sliding window** approach using two hash maps. The algorithmic approach can be summarized as follows:
 
 1. Add a preliminary corner case condition by checking the second substring is empty or not. If it is empty, then return the empty substring as minimum window substring.
 
-2. Initialize two HashMaps, which store unique characters and their respective character count for the given two substrings.
+2. Initialize two HashMaps(`windowStrCount` & `subStrCount`), which store unique characters and their respective character count for their given substrings.
 
-3. Initialize minLength variable to max integer value, to store the length of the minimum window substring.
+3. Initialize `minLength` variable with maximum integer value, which is used to store the length of the minimum window substring.
 
-4. Initialize left(leftIndex) and right(rightIndex) indexes to -1, to keep track of the minimum substring window boundaries.
+4. Initialize substring boundaries(`subStrBoudaries`) variable to [-1, -1], which is used to keep track of the minimum substring window boundaries.
 
-5. Iterate over the second substring and count the character count using hashmap. 
+5. Iterate over the second substring and count the character count using respective hashmap. 
 
-6. Initialize total character count(i.e, `required`) from second substring to max integer value and total character count(i.e, `having`) of first substring based on first substring to 0. 
+6. Initialize second substring's required character count(i.e, `required`) to the size of second hashmap and total character count(i.e, `having`) of first substring to 0. 
 
 7. Initialize both left and right pointers to 0, to keep track of the current window substring. 
 
-8. Iterate through second substring using right pointer until the end of string.
+8. Iterate through first substring using right pointer until the end of string.
 
-9. If the current character from first substring exists in second substring hashmap, update the character counter of first hashmap. Also, increment `having` variable if the character count in both hashmaps are equal.
+9. If the current character from first substring exists in second substring hashmap, update the character count of first hashmap. Also, increment `having` variable if the character count in both hashmaps are equal.
 
-10. Until `required` and `having` variables are equal, first calculate the left and right indexes along with `minLength` variable. Thereafter, move/increment the left pointer and decrement the character count in first hashmap to find the minimum possible substring window. If the current left character found in second hashmap and first hashmap character count is less than second one, `having` variable needs to be decremented.
+10. Iterate a nested loop until `required` and `having` variables are equal. If the current substring's length is less than minimum substring's length which is calculated so far, just update `minLength` variable with current substring length and also the substring boundaries. Thereafter, shrink (or remove the left character) the substring window and decrement the character count in first hashmap. This logic is required to find the minimum possible substring window in the first string. If the current left character found in second hashmap and first hashmap character count is less than second one, `having` variable needs to be decremented.
 
 11. Repeat steps 9-10 until the end of the first string.
 
-7. If the leftIndex and rightIndex are still equals to -1, return empty string. Otherwise the substring based on leftIdex and rightIndex should be returned from first string.
+12. Return an empty string if the minimum substring length is not a maximum value. Otherwise return the substring of first string based on substring boundary index values.
 
 
 **Time and Space complexity:**
-This algorithm has a time complexity of `O(m) + O(n)`, where m and n represents lenghts of first and second strings. This is because we are traversing both the strings. Also, it requires space complexity of `O(m) + O(n)` due to two hashmaps used to store character count.
+This algorithm has a time complexity of `O(m) + O(n)`, where `m` and `n` represents lengths of first and second strings. This is because we are traversing both the strings. 
+
+Also, it requires space complexity of `O(m) + O(n)` due to two hashmaps used to store the character count.

src/javascript/algorithms/strings/minWindowSubstring/minWindowSubstring.js src/javascript/algorithms/strings/3.minWindowSubstring/minWindowSubstring.js

@@ -5,7 +5,7 @@ function minWindowSubstring(windowStr, subStr) {
     let subStrCount = new Map();
 
     let minLength = Number.MAX_VALUE;
-    let leftIndex = rightIndex = -1;
+    let subStrboundaries = [-1, -1];
 
     for(const ch of subStr) {
         subStrCount.set(ch, (subStrCount.get(ch) || 0) + 1);
@@ -15,10 +15,10 @@ function minWindowSubstring(windowStr, subStr) {
     let left = 0;
 
     for(let right = 0; right < windowStr.length; right++) {
-        let rightChar = windowStr.charAt(right);
+        let rightChar = windowStr[right];
 
         if(subStrCount.has(rightChar)) {
-            windowStrCount.set(rightChar, (windowStrCount.get(right) || 0) +1);
+            windowStrCount.set(rightChar, (windowStrCount.get(rightChar) || 0) +1);
             if(subStrCount.get(rightChar) === windowStrCount.get(rightChar)) {
                 having++;
             }
@@ -27,11 +27,11 @@ function minWindowSubstring(windowStr, subStr) {
         while(required === having) {
             if(minLength > right-left+1) {
                 minLength = right-left+1;
-                leftIndex = left;
-                rightIndex = right;
+                subStrboundaries[0] = left;
+                subStrboundaries[1] = right;
             }
 
-            let leftChar = windowStr.charAt(left);
+            let leftChar = windowStr[left];
             if(subStrCount.has(leftChar)) {
                 windowStrCount.set(leftChar, windowStrCount.get(leftChar)-1);
                 if(windowStrCount.get(leftChar) < subStrCount.get(leftChar)) {
@@ -41,12 +41,8 @@ function minWindowSubstring(windowStr, subStr) {
             left++;
         }
     }
-    if(leftIndex === -1 || rightIndex === -1) {
-        return "";
-    } else {
-        return windowStr.substring(leftIndex, rightIndex+1);
-    }
 
+    return minLength === Number.MAX_VALUE ? "" : windowStr.substring(subStrboundaries[0], subStrboundaries[1]+1);
 }
 
 let s1 ="ADOBECODEBANC", t1= "ABC";

src/javascript/algorithms/strings/3.minWindowSubstring/minWindowSubstring.md

@@ -0,0 +1,51 @@
+**Description:**
+Given two strings `str` and `subStr` of lengths `m` and `n` respectively, return the minimum window 
+substring of `str` such that every character in `subStr` (including duplicates) is included in the window. If there is no such substring available, just return the empty string(i.e,"").
+
+### Examples
+Example 1:
+
+Input: str = "ADOBECODEBANC", subStr = "ABC"
+Output: "BANC"
+Explanation: The minimum window substring "BANC" includes 'A', 'B', and 'C' from string t.
+
+Example 2:
+Input: str = "A", subStr = "A"
+Output: "A"
+
+Example 3:
+Input: str = "a", subStr = "aa"
+Output: ""
+
+**Algorithmic Steps**
+This problem is solved with the help of **sliding window** approach using two hash maps. The algorithmic approach can be summarized as follows:
+
+1. Add a preliminary corner case condition by checking the second substring is empty or not. If it is empty, then return the empty substring as minimum window substring.
+
+2. Initialize two HashMaps(`windowStrCount` & `subStrCount`), which store unique characters and their respective character count for their given substrings.
+
+3. Initialize `minLength` variable with maximum integer value, which is used to store the length of the minimum window substring.
+
+4. Initialize substring boundaries(`subStrBoudaries`) variable to [-1, -1], which is used to keep track of the minimum substring window boundaries.
+
+5. Iterate over the second substring and count the character count using respective hashmap. 
+
+6. Initialize second substring's required character count(i.e, `required`) to the size of second hashmap and total character count(i.e, `having`) of first substring to 0. 
+
+7. Initialize both left and right pointers to 0, to keep track of the current window substring. 
+
+8. Iterate through first substring using right pointer until the end of string.
+
+9. If the current character from first substring exists in second substring hashmap, update the character count of first hashmap. Also, increment `having` variable if the character count in both hashmaps are equal.
+
+10. Iterate a nested loop until `required` and `having` variables are equal. If the current substring's length is less than minimum substring's length which is calculated so far, just update `minLength` variable with current substring length and also the substring boundaries. Thereafter, shrink (or remove the left character) the substring window and decrement the character count in first hashmap. This logic is required to find the minimum possible substring window in the first string. If the current left character found in second hashmap and first hashmap character count is less than second one, `having` variable needs to be decremented.
+
+11. Repeat steps 9-10 until the end of the first string.
+
+12. Return an empty string if the minimum substring length is not a maximum value. Otherwise return the substring of first string based on substring boundary index values.
+
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(m) + O(n)`, where `m` and `n` represents lengths of first and second strings. This is because we are traversing both the strings. 
+
+Also, it requires space complexity of `O(m) + O(n)` due to two hashmaps used to store the character count.