add some more

Author: chihungyu1116

159 Longest Substring with At Most Two Disctinct Characters.js

@@ -0,0 +1,46 @@
+// https://segmentfault.com/a/1190000003790746
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var lengthOfLongestSubstringTwoDistinct = function(s) {
+    var longestSubstr = "";
+    var maxLength = 0;
+    var start = 0;
+    var map = new Map();
+    
+    for(var i = 0; i < s.length; i++) {
+        var c = s.charAt(i);
+        
+        // if map already contains two distrinct chars and the char is new to the map
+        if(map.size > 1 && map.get(c) === undefined) {
+            var leftMost = s.length;
+              
+            // Calc substring len before the new char
+            if(i - start > maxLength) {
+                // Should not include i, since i is the new distinct char's index
+                longestSubstr = s.substring(start, i);
+                maxLength = longestSubstr.length;
+            }
+            
+            map.forEach((charIdx, key)=> {
+                if(charIdx < leftMost) {
+                    leftMost = charIdx;
+                }
+            });
+                      
+            start = leftMost + 1;
+            map.delete(s[leftMost]);
+        }
+        
+        map.set(c, i);
+    }
+    
+    if(s.length - start > maxLength) {
+        longestSubstr = s.substring(start, s.length);
+        maxLength = longestSubstr.length;
+    }
+    
+    return maxLength;
+};

314 Binary Tree Vertical Order Traversal.js

@@ -0,0 +1,63 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[][]}
+ */
+
+var verticalOrder = function(root) {
+    var map = {};
+    var queue = [];
+    var res = [];
+    // since iterating over map cannot ensure order
+    // we store min and max index for enforcing that
+    var minIdx = Infinity;
+    var maxIdx = -Infinity;
+    
+    if(root === null) {
+        return res;
+    }
+    
+    queue.push([0, root]);
+    while(queue.length > 0) {
+        var len = queue.length;
+        
+        for(var i = 0; i < len; i++) {
+            var data = queue.shift();
+            var cur = data[1];
+            var idx = data[0];
+            
+            if(idx < minIdx) {
+                minIdx = idx;
+            }
+            if(idx > maxIdx) {
+                maxIdx = idx;
+            }
+            
+            map[idx] = map[idx] || [];
+            map[idx].push(cur.val);
+            
+            if(cur.left) {
+                queue.push([idx - 1, cur.left]);
+            }
+            if(cur.right) {
+                queue.push([idx + 1, cur.right]);
+            }
+        }
+    }
+    // since iterating over map cannot ensure order
+    for(i = minIdx; i <= maxIdx; i++) {
+        var key = i.toString();
+        
+        if(map[key]) {
+            res.push(map[key]);
+        }
+    }
+    
+    return res;
+};

340 Longest Substring With At Most K Distinct Characters.js

@@ -0,0 +1,49 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+var lengthOfLongestSubstringKDistinct = function(s, k) {
+    var longestSubstr = "";
+    var maxLength = 0;
+    var start = 0;
+    var map = new Map();
+    
+    if(k === 0) {
+        return 0;
+    }
+    
+    for(var i = 0; i < s.length; i++) {
+        var c = s.charAt(i);
+        
+        // if map already contains two distrinct chars and the char is new to the map
+        if(map.size >= k && map.get(c) === undefined) {
+            var leftMost = s.length;
+              
+            // Calc substring len before the new char
+            if(i - start > maxLength) {
+                // Should not include i, since i is the new distinct char's index
+                longestSubstr = s.substring(start, i);
+                maxLength = longestSubstr.length;
+            }
+            
+            map.forEach((charIdx, key)=> {
+                if(charIdx < leftMost) {
+                    leftMost = charIdx;
+                }
+            });
+                      
+            start = leftMost + 1;
+            map.delete(s[leftMost]);
+        }
+        
+        map.set(c, i);
+    }
+    
+    if(s.length - start > maxLength) {
+        longestSubstr = s.substring(start, s.length);
+        maxLength = longestSubstr.length;
+    }
+    
+    return maxLength;  
+};

56. Merge Intervals.js

@@ -0,0 +1,40 @@
+/**
+ * Definition for an interval.
+ * function Interval(start, end) {
+ *     this.start = start;
+ *     this.end = end;
+ * }
+ */
+/**
+ * @param {Interval[]} intervals
+ * @return {Interval[]}
+ */
+var merge = function(intervals) {
+    
+    // http://yucoding.blogspot.com/2013/01/leetcode-question-51-merge-intervals.html
+    
+    var result = [];
+    
+    if(!intervals || intervals.length === 0) {
+        return result;
+    }
+    
+    intervals.sort((a, b)=> {
+        return a.start > b.start ? 1 : -1;
+    });
+    
+    result.push(intervals[0]);
+    
+    for(var i = 1; i < intervals.length; i++) {
+        var topOfResult = result[result.length - 1];
+        var interval = intervals[i];
+        
+        if(topOfResult.end >= interval.start) {
+            topOfResult.end = Math.max(topOfResult.end, interval.end);
+        } else {
+            result.push(interval);
+        }
+    }
+    
+    return result;
+};

57. Insert Interval.js

@@ -0,0 +1,47 @@
+/**
+ * Definition for an interval.
+ * function Interval(start, end) {
+ *     this.start = start;
+ *     this.end = end;
+ * }
+ */
+/**
+ * @param {Interval[]} intervals
+ * @param {Interval} newInterval
+ * @return {Interval[]}
+ */
+ 
+//  http://bangbingsyb.blogspot.com/2014/11/leetcode-insert-interval.html
+var insert = function(intervals, newInterval) {
+    var result = [];
+    // Easier to consider if two sections are not overlapped
+    // [s1, e1] [s2, e2] --> e2 < s1 or e1 < s2
+    // once merged when two sections are overlapped, [min(s1,s2), max(e1,e2)]
+    
+    var isInsert = false;
+    
+    for(var i = 0; i < intervals.length; i++) {
+        var interval = intervals[i];
+        
+        if(isInsert) {
+            result.push(interval);
+        } else if(newInterval.end < interval.start) {
+            result.push(newInterval);
+            result.push(interval);
+            isInsert = true;
+        } else if(newInterval.start <= interval.end && interval.start <= newInterval.end){
+            
+            newInterval.start = Math.min(newInterval.start, interval.start);
+            newInterval.end = Math.max(newInterval.end, interval.end);
+            continue;
+        } else {
+            result.push(interval);
+        }
+    }
+    
+    if(!isInsert) {
+        result.push(newInterval);
+    }
+    
+    return result;
+};

96 Unique Binary Search Trees.js

@@ -2,6 +2,7 @@
  * @param {number} n
  * @return {number}
  */
+ // https://www.youtube.com/watch?v=YDf982Lb84o
 var numTrees = function(n) {
     var result = [1, 1];
 
@@ -14,3 +15,35 @@ var numTrees = function(n) {
     }
     return result[n];
 };
+
+
+// var numTrees = function(n) {
+//     var i,
+//         j,
+//         result = [];
+    
+//     result[0] = 1;
+//     result[1] = 1;
+    
+//     for (i = 2; i <= n; i++) {
+//         result[i] = 0;
+//         for (j = 0; j < i; j++) {
+//             result[i] += result[j] * result[i - 1 - j];
+//             console.log(i, j, i - 1 - j, result)
+//         }
+        
+//     }
+//     return result[n];
+// };
+
+
+numTrees(4);
+
+
+1, 2, 3, 4
+
+j = r[0]
+k = r[3]
+
+j = r[1]
+k = r[2]

Javascript Closure Questions.js

@@ -0,0 +1,24 @@
+// implement function add in such a way that:
+// add() => 0
+// add(1)(2)() => 3
+// add(n0)(n1)...(nk)() => n0+n1+...+nk
+
+function add(val){
+    var total = 0;
+    var result;
+    var step = function(val){
+        if(val === undefined){
+            result = total;
+            total = 0;
+            return result;
+        } else {
+            total += val;
+        }
+    
+        return step;
+    }
+    
+    result = step(val);
+    
+    return result;
+}

README.md

@@ -42,6 +42,7 @@ Leetcode Problems in Javascript
 152 Maximum Product Subarray.js
 153 Find Minimum in Rotated Sorted Array.js
 155 Min Stack.js
+159 Longest Substring with At Most Two Disctinct Characters.js
 16 3Sum Closest.js
 160 Intersection Of Two Linked Lists.js
 162 Find Peak Element.js
@@ -75,7 +76,6 @@ Leetcode Problems in Javascript
 21 Merge Two Sorted Lists.js
 211 Add and Search Word - Data structure design.js
 215 Kth Largest Element in an Array.js
-215 Kth Largest Element in an Array.py
 217 Contain Duplicate.js
 219 Contains Duplicate II.js
 22 Generate Parentheses.js
@@ -111,11 +111,13 @@ Leetcode Problems in Javascript
 3 Longest Substring Without Repeating Characters.js
 300 Longest Increasing Subsequence.js
 31 Next Permutation.js
+314 Binary Tree Vertical Order Traversal.js
 318 Maximum Product of Word Lengths My Submissions Question.js
 322 Coin Change.js
 33 Search in Rotated Sorted Array.js
 335 Self Crossing.js
 34 Search for a Range.js
+340 Longest Substring With At Most K Distinct Characters.js
 35 Search Insert Position.js
 36 Valid Sudoku.js
 37 Sudoku Solver.js
@@ -134,6 +136,8 @@ Leetcode Problems in Javascript
 53 Maximum Subarray.js
 54 Spiral Matrix.js
 55 Jump Game.js
+56. Merge Intervals.js
+57. Insert Interval.js
 58 Length of Last Word.js
 59 Spiral Matrix II.js
 61 Rotate List.js
@@ -163,4 +167,12 @@ Leetcode Problems in Javascript
 93 Restore IP Addresses.js
 94 Binary Tree Inorder Traversal.js
 96 Unique Binary Search Trees.js
-98 Validate Binary Search Tree.js
+98 Validate Binary Search Tree.js
+Hackrank.js
+Javascript Closure Questions.js
+Jump Game II.js
+Rate Limiter.js
+Reverse Integer.js
+String Encoding and Decoding.js
+find kth element in two arrays.js
+flatten nested array.js