refactor: js - slidewindow (neetcode-gh#454)

aakhtar3 · web-flow · commit 80d92b9a845a · 2022-07-30T16:02:29.000-04:00
diff --git a/javascript/121-Best-Time-to-Buy-and-Sell-Stock.js b/javascript/121-Best-Time-to-Buy-and-Sell-Stock.js
@@ -1,16 +1,21 @@
 /**
- * @param {number[]} prices
+ * https://leetcode.com/problems/best-time-to-buy-and-sell-stock/
+ * Time O(N) | Space O(1)
+ * @param {number} prices
  * @return {number}
  */
-var maxProfit = function (prices) {
-    let buy = prices[0];
-    let profit = 0;
-    for (let i = 0; i < prices.length; i++) {
-        if (prices[i] < buy) {
-            buy = prices[i];
-        } else {
-            profit = Math.max(prices[i] - buy, profit);
-        }
+var maxProfit = function(prices) {
+    let [ left, right, max ] = [ 0, 1, 0];
+
+    while (right < prices.length) {
+        const canSlide = prices[right] <= prices[left];
+        if (canSlide) left = right;
+
+        const window = prices[right] - prices[left];
+
+        max = Math.max(max, window);
+        right++;
     }
-    return profit;
-};
+
+    return max;
+}
diff --git a/javascript/3-Longest-Substring-Without-Repeating-Characters.js b/javascript/3-Longest-Substring-Without-Repeating-Characters.js
@@ -1,22 +1,28 @@
-var lengthOfLongestSubstring = function (str) {
-    const hash = {};
-    let start = 0;
-    let max = 0;
+/**
+ * https://leetcode.com/problems/longest-substring-without-repeating-characters/
+ * Time O(N) | Space O(N)
+ * @param {string} s
+ * @return {number}
+ */
+var lengthOfLongestSubstring = function(s, map = new Map()) {
+    let [ left, right, max ] = [ 0, 0, 0];
 
-    for (let i = 0; i < str.length; i++) {
-        let rightChar = str[i];
+    while (right < s.length) {
+        const rightChar = s[right];
 
-        if (!(rightChar in hash)) hash[rightChar] = 0;
-        hash[rightChar] += 1;
+        const canSlide = map.has(rightChar);
+        if (canSlide) {
+            const rightIndex = map.get(rightChar) + 1;
 
-        while (hash[rightChar] > 1) {
-            let leftChar = str[start];
-            start += 1;
-
-            if (leftChar in hash) hash[leftChar] -= 1;
-            if (hash[leftChar] === 0) delete hash[leftChar];
+            left = Math.max(left, rightIndex);
         }
-        max = Math.max(max, i - start + 1);
+
+        const window = (right - left) + 1;
+
+        max = Math.max(max, window);
+        map.set(rightChar, right);
+        right++;
     }
+
     return max;
 };
diff --git a/javascript/424-Longest-Repeating-Character-Replacement.js b/javascript/424-Longest-Repeating-Character-Replacement.js
@@ -1,30 +1,52 @@
 /**
+ * https://leetcode.com/problems/longest-repeating-character-replacement/
+ * Time O(((N + 26) * N) * (M - N)) | Space O(1)
  * @param {string} s
  * @param {number} k
  * @return {number}
  */
-var characterReplacement = function (s, k) {
-    let sCharacterSet = {};
-    let result = 0;
-    let l = 0;
-    let maxLength = 0;
-
-    for (let r = 0; r < s.length; r++) {
-        if (sCharacterSet[s[r]] !== undefined) {
-            sCharacterSet[s[r]] = 1 + sCharacterSet[s[r]];
-        } else {
-            sCharacterSet[s[r]] = 1;
-        }
+var characterReplacement = function(s, k) {
+    let [ left, right, longest, max ] = new Array(4).fill(0);
+    const frequencyMap = new Array(26).fill(0);
 
-        maxLength = Math.max(maxLength, sCharacterSet[s[r]]);
+    while (right < s.length) {
+        const count = addRightFrequency(s, right, frequencyMap);
+        
+        longest = Math.max(longest, count);
 
-        if (r - l + 1 - maxLength > k) {
-            sCharacterSet[s[l]] -= 1;
-            l += 1;
+        let window = (right - left) + 1;
+        const canSlide = k < (window - longest);
+        if (canSlide) {
+            subtractLeftFrequency(s, left, frequencyMap);
+            left++;
         }
 
-        result = Math.max(result, r - l + 1);
+        window = (right - left) + 1;
+        max = Math.max(max, window);
+        
+        right++;
     }
-
-    return result;
+    
+    return max;
 };
+
+const addRightFrequency = (s, right, map) => {
+    const char = s[right];
+    const index = getCode(char);
+
+    map[index]++;
+    
+    return map[index];
+}
+
+const subtractLeftFrequency = (s, left, map) => {
+    const char = s[left];
+    const index = getCode(char);
+
+    map[index]--;
+    
+    return map[index];
+}
+
+const getCode = (char) => char.charCodeAt(0) - 'A'.charCodeAt(0);
+
diff --git a/javascript/567-Permutation-In-String.js b/javascript/567-Permutation-In-String.js
@@ -1,3 +1,76 @@
+/**
+ * https://leetcode.com/problems/permutation-in-string/
+ * Time O(N + (M - N)) | Space O(1)
+ * @param {string} s1
+ * @param {string} s2
+ * @return {boolean}
+ */
+var checkInclusion = (s1, s2) => {
+    const isInvalid = s2.length < s1.length
+    if (isInvalid) return false;
+    
+    let [ left, right ] = [ 0, 0 ];
+    const [ s1FrequencyMap, s2FrequencyMap ] = getFrequencyMaps(s1);
+    
+    while (right < s2.length) {
+        addRightFrequency(s2, right, s2FrequencyMap);
+
+        const window = (right - left) + 1;
+        const isPermutation = (window === s1.length) && isSame(s1FrequencyMap, s2FrequencyMap);
+        if (isPermutation) return true;
+
+        const canSlide = s1.length <= window;
+        if (canSlide) {
+            subtractLeftFrequency(s2, left, s2FrequencyMap);
+            left++;
+        }
+        
+        right++;
+    }
+    
+    return false;
+}
+
+const getFrequencyMaps = (s1) => {
+    const [ s1FrequencyMap, s2FrequencyMap ] = new Array(2)
+        .fill().map(() => new Array(26).fill(0))
+
+    for (const char of s1) s1FrequencyMap[getCode(char)]++;
+
+    return [ s1FrequencyMap, s2FrequencyMap ]
+}
+
+
+const getCode = (char) => char.charCodeAt(0) - 'a'.charCodeAt(0);
+
+const addRightFrequency = (s, right, frequencyMap) => {
+    const char = s[right];
+    const index = getCode(char);
+
+    frequencyMap[index]++;
+    
+    return frequencyMap[index];
+}
+
+const subtractLeftFrequency = (s, left, frequencyMap) => {
+    const char = s[left];
+    const index = getCode(char);
+
+    frequencyMap[index]--;
+    
+    return frequencyMap[index];
+}
+
+const isSame = (a, b) => {
+    for (let i = 0; i < 26; i++) {
+        const isMatch = a[i] === b[i];
+        if (!isMatch) return false
+    }
+    
+    return true;
+}
+
+
 //////////////////////////////////////////////////////////////////////////////
 // Static Sliding Window
 // Time: Theta(l1 + l2) O(l1 + l2)  Space: Theta(1) O(1)
@@ -13,7 +86,7 @@
  * @param {string} s2
  * @return {boolean}
  */
-function checkInclusion(s1, s2) {
+ function checkInclusion(s1, s2) {
     if (s1.length > s2.length) {
         return false;
     }
@@ -150,4 +223,4 @@ function checkInclusion(s1, s2) {
     }
 
     return false;
-}
+}
diff --git a/javascript/76-Minimum-Window-Substring.js b/javascript/76-Minimum-Window-Substring.js
@@ -1,37 +1,79 @@
-var minWindow = function (str, target) {
-    const hash = target.split('').reduce((acc, val) => {
-        if (!acc[val]) acc[val] = 0;
-        acc[val] += 1;
-        return acc;
-    }, {});
-
-    let start = 0;
-    let min = Infinity;
-    let matched = 0;
-    let subStringStart = null;
-
-    for (let i = 0; i < str.length; i++) {
-        let rightChar = str[i];
-
-        if (rightChar in hash) hash[rightChar] -= 1;
-        if (hash[rightChar] >= 0) matched += 1;
-
-        while (matched === target.length) {
-            if (i - start + 1 < min) {
-                subStringStart = start;
-                min = i - start + 1;
-            }
+/**
+ * https://leetcode.com/problems/minimum-window-substring/
+ * Time O(N + M) | SpaceO(N + M)
+ * @param {string} s
+ * @param {string} t
+ * @return {string}
+ */
+var minWindow = function (s, t) {
+    const isMissingArgs = !s.length || !t.length
+    if (isMissingArgs) return '';
+
+    const frequencyMap = getFrequencyMap(t);
+    const { start, end } = getWindowPointers(s, t, frequencyMap);
+
+    return getSubString(s, start, end);
+}
+
+const getFrequencyMap = (str, frequencyMap = new Map()) => {
+    for (const char of str) {
+        frequencyMap.set(char, (frequencyMap.get(char) || 0) + 1);
+    }
+
+    return frequencyMap;
+};
+
+const getWindowPointers = (s, t, frequencyMap) => {
+    let [ left, right, matched, start, end ] = [ 0, 0, 0, 0, (s.length + 1) ];
+    
+    while (right < s.length) {
+        matched = addRightFrequency(s, right, frequencyMap, matched);
 
-            let leftChar = str[start];
-            start += 1;
+        const canSlide = () => matched === t.length;
+        while (canSlide()) {
+            const window = (right - left) + 1;
 
-            if (leftChar in hash) {
-                if (hash[leftChar] === 0) matched -= 1;
-                hash[leftChar] += 1;
+            const isSmaller = window < end;
+            if (isSmaller) {
+                [ start, end ] = [ left, window ];
             }
+
+            matched = subtractLeftFrequency(s, left, frequencyMap, matched);
+            left++;
         }
+
+        right++;
+    }
+
+    return { start, end };
+};
+
+const addRightFrequency = (s, right, frequencyMap, matched) => {
+    const char = s[right];
+
+    if (frequencyMap.has(char)) {
+        frequencyMap.set(char, frequencyMap.get(char) - 1);
+
+        const isInWindow = 0 <= frequencyMap.get(char);
+        if (isInWindow) matched++;
+    }
+
+    return matched;
+};
+
+const subtractLeftFrequency = (s, left, frequencyMap, matched) => {
+    const char = s[left];
+
+    if (frequencyMap.has(char)) {
+        const isOutOfWindow = frequencyMap.get(char) === 0;
+        if (isOutOfWindow) matched--;
+
+        frequencyMap.set(char, frequencyMap.get(char) + 1);
     }
-    return min === Infinity
-        ? ''
-        : str.substring(subStringStart, subStringStart + min);
+
+    return matched;
 };
+
+const getSubString = (s, start, end) => end <= s.length
+    ? s.slice(start, start + end)
+    : '';
