add comment

Author: Chihung Yu

11 Container With Most Water.js

@@ -1,3 +1,29 @@
+// Given n non-negative integers a1, a2, ..., an , where each represents a point at coordinate (i, ai). n vertical lines are drawn such that the two endpoints of line i is at (i, ai) and (i, 0). Find two lines, which together with x-axis forms a container, such that the container contains the most water.
+//
+// Note: You may not slant the container and n is at least 2.
+//
+// The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In this case, the max area of water (blue section) the container can contain is 49.
+//
+// Example:
+//
+// Input: [1,8,6,2,5,4,8,3,7]
+// Output: 49
+//
+
+
+// Given fixed set of vertical bars
+// Min case
+//
+//     . .
+//   . . . .
+// . . . . . .
+
+// Max case
+//
+// .         .
+// . .     . .
+// . . . . . .
+
 /**
  * @param {number[]} height
  * @return {number}
@@ -6,17 +32,17 @@ var maxArea = function(height) {
     var left = 0;
     var right = height.length - 1;
     var maxVal = 0;
-    
+
     while(left<right){
         var contain = (right-left)*Math.min(height[left],height[right]);
         maxVal = Math.max(contain, maxVal);
-        
+
         if(height[left] >= height[right]){
             right--;
         } else {
             left++;
         }
     }
-    
+
     return maxVal;
-};
+};

31 Next Permutation.js

@@ -6,13 +6,22 @@
 var nextPermutation = function(nums) {
     var vioIndex = nums.length - 1;
 
+    
+    // example
+    // 1. 687432
+    // the violation index is 1 (number 8) since it's greater than index 0 (number 6)
+    // 2. 87452
+    // the violation index is 3 (number 5) since it's greater than index 2 (number 4)
     while(vioIndex > 0) {
         if(nums[vioIndex - 1] < nums[vioIndex]) {
             break;
         }
         vioIndex--;
     }
-    
+
+
+    // If it's not already the maximum value i.e. 876432 in the example of 687432 the maximum is 876432
+    // then swap the the 6 with 7 since 7 a just a tad bigger
     if(vioIndex > 0) {
         vioIndex--;
         var first = nums.length - 1;
@@ -37,4 +46,49 @@ var nextPermutation = function(nums) {
         end--;
         vioIndex++;
     }
+};
+
+
+
+/**
+ * @param {number[]} nums
+ * @return {void} Do not return anything, modify nums in-place instead.
+ */
+var nextPermutation = function(nums) {
+    var violatedIndex = nums.length - 1;
+    
+    while(violatedIndex > 0) {
+        if (nums[violatedIndex] > nums[violatedIndex-1]) {
+            break;
+        }
+        violatedIndex--;
+    }
+    
+    // max
+    if (violatedIndex > 0) {
+        violatedIndex--;
+        
+        var indexToSwapWith = nums.length - 1;
+        while(indexToSwapWith > violatedIndex) {
+            if (nums[indexToSwapWith] > nums[violatedIndex]) {
+                var temp = nums[violatedIndex];
+                nums[violatedIndex] = nums[indexToSwapWith];
+                nums[indexToSwapWith] = temp;
+                break;
+            }
+            indexToSwapWith--
+        }
+        
+        violatedIndex++;
+    }
+        
+    var end = nums.length - 1;
+
+    while(end > violatedIndex) {
+        temp = nums[violatedIndex];
+        nums[violatedIndex] = nums[end];
+        nums[end] = temp;
+        end--
+        violatedIndex++;
+    }
 };

55 Jump Game.js

@@ -11,6 +11,5 @@ var canJump = function(nums) {
         }
         numLeft = Math.max(nums[i], numLeft);
     }
-    
-    return numLeft >= 0;
+    return true;
 };

76 Minimum Window Substring.js

@@ -26,8 +26,8 @@ var minWindow = function(s, t) {
     var lenS = s.length;
     var lenT = t.length;
     var queue = [];
-    var tRequireCount = {};
-    var tFoundCount = {};
+    var tRequireCount = {}; // string T required count
+    var tFoundCount = {}; // string T found count
     var hasFound = 0;
     var windowBeg = -1;
     var windowEnd = lenS;
@@ -41,6 +41,7 @@ var minWindow = function(s, t) {
     }
 
     for(i = 0; i < lenS; i++) {
+        // cannot use tRequireCount[s[i]] !== 0 since tRequireCount[s[i]] might be undefined
         if(tRequireCount[s[i]] > 0) {
             // use queue to skip a lot of redudant character
             // minWindow('aeeeeeebceeeeaeeedcb', 'abc');
@@ -53,7 +54,13 @@ var minWindow = function(s, t) {
 
             // if found count is over require count, we don't need those extra, so don't record it to hasFound
             if(tFoundCount[s[i]] <= tRequireCount[s[i]]) {
-                hasFound++;
+                // hasFound is used as a flag for knowing where we should check against T string and when we should start reducing the range
+                // for example
+                // minWindow('aaaaebceeeeaeeedcb', 'abc');
+                // at index 5 where s[i] is e, hasFound is 1 and tFoundCount['a'] is 4, queue=[0,1,2,3]
+                // when we arrive at index 7 where s[i] is c, has found is now 3 and is equal to lenT
+                // now we can start reducing the range all the way from index 0(a) to index 7(c) to index 3(a) to index 7 (c) which will give us the min
+                hasFound++; 
             }
 
             // when the current location which is in queue
@@ -73,9 +80,67 @@ var minWindow = function(s, t) {
                     // 1st round 0 8 
                     // 2nd round 7 13
                 }
+                // since i must be the last match that leads to hasFound === lenT
+                hasFound--;
+            }
+        }
+    }
+    
+    return windowBeg !== -1 ? s.substring(windowBeg, windowEnd + 1) : '';
+};
+
 
+
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {string}
+ */
+var minWindow = function(s, t) {
+    var lenS = s.length;
+    var lenT = t.length;
+    var tCharToFoundCount = {};
+    var tCharToRequiredCount = {};
+    
+    for(var i = 0; i < lenT; i++) {
+        var c = t[i];
+        tCharToFoundCount[c] = 0;
+        tCharToRequiredCount[c] = tCharToRequiredCount[c] || 0;
+        tCharToRequiredCount[c]++;
+    }
+    
+    var windowBeg = -1;
+    var windowEnd = lenS;
+    var queue = [];
+    var hasFound = 0;
+    for(i = 0; i < lenS; i++) {
+        c = s[i];
+        // skip unneeded char
+        if (tCharToRequiredCount[c] !== 0) {
+            tCharToFoundCount[c]++;
+            queue.push(i);
+            
+            if (tCharToFoundCount[c] <= tCharToRequiredCount[c]) {
+                hasFound++;
+            }
+            
+            if (hasFound === lenT) {
+                var k;
+                
+                do {
+                    k = queue.shift();
+                    tCharToFoundCount[s[k]]--;
+                } while(tCharToFoundCount[s[k]] >= tCharToRequiredCount[s[k]]);
+                
+                if (windowEnd - windowBeg > i - k) {
+                    windowBeg = k;
+                    windowEnd = i;
+                }
+                
                 hasFound--;
             }
+            
+            
         }
     }
 

[0003] Longest Substring Without Repeating Characters.js

@@ -4,6 +4,9 @@
  */
 
 
+// use map for storing index
+// if a repeated character is found, skip directly to the index of the repeated character in the map.
+
 var lengthOfLongestSubstring = function(s) {
     if(s === null || s.length === 0){
         return 0;