add more solutions

Author: chihungyu1116

173 Binary Search Tree Iterator.js

@@ -1,3 +1,18 @@
+// Implement an iterator over a binary search tree (BST). Your iterator will be initialized with the root node of a BST.
+
+// Calling next() will return the next smallest number in the BST.
+
+// Note: next() and hasNext() should run in average O(1) time and uses O(h) memory, where h is the height of the tree.
+
+// Credits:
+// Special thanks to @ts for adding this problem and creating all test cases.
+
+// Hide Company Tags LinkedIn Google Facebook Microsoft
+// Hide Tags Tree Stack Design
+// Hide Similar Problems (M) Binary Tree Inorder Traversal (M) Flatten 2D Vector (M) Zigzag Iterator (M) Peeking Iterator (M) Inorder Successor in BST
+
+
+
 /**
  * Definition for binary tree
  * function TreeNode(val) {

209 Minimum Size Subarray Sum.js

@@ -1,30 +1,58 @@
 // http://blog.csdn.net/lisonglisonglisong/article/details/45666975
+// http://www.cnblogs.com/grandyang/p/4501934.html
+
+// Given an array of n positive integers and a positive integer s, find the minimal length of a subarray of which the sum ≥ s. If there isn't one, return 0 instead.
+
+// For example, given the array [2,3,1,2,4,3] and s = 7,
+// the subarray [4,3] has the minimal length under the problem constraint.
+
+// click to show more practice.
+
+// Credits:
+// Special thanks to @Freezen for adding this problem and creating all test cases.
+
+// Hide Company Tags Facebook
+// Hide Tags Array Two Pointers Binary Search
+// Hide Similar Problems (H) Minimum Window Substring (M) Maximum Size Subarray Sum Equals k
+
 
 /**
  * @param {number} s
  * @param {number[]} nums
  * @return {number}
  */
+
+// O(n) solution
 var minSubArrayLen = function(s, nums) {
     var sum = 0;
     var left = 0;
-    var right = -1;
-    var len = nums.length;
+    var right = 0;
     var minLen = Infinity;
 
-    while(right < len) {
-        while(right < len && sum < s) {
-            sum += nums[++right];
-        }
-        if(sum >= s) {
-            minLen = Math.min(right - left + 1, minLen);
-            sum -= nums[left];
-            left++;
+    while(right < nums.length) {
+        while(right < nums.length && sum < s) {
+            sum += nums[right++];
         }
 
+        while(sum >= s) {
+            minLen = Math.min(minLen, right - left);
+            sum -= nums[left++];
+        }
     }
 
-    
-    
-    return minLen > len ? 0 : minLen;
-};
+    return minLen > nums.length ? 0 : minLen;
+};
+
+// The O(NlogN) solution is to sum up the array
+// [1,2,3,4,5] becomes [1,3,6,10,15]
+// then iterate through array from index 0 to nums.length - 1
+// for each value in the summed array
+// binary search values after that index so the difference becomes greater than s
+// example
+// s = 8
+// at index 0 with value 1 look between [3,6,10,15] using binary search.
+// we can find that at value 10 the difference is 10 - 1 = 9 the minLen is index 3 - 1 + 1 = 3
+// then we check index 1 with value 3 and binary search [6,10,15] we can find that at value 15 we have difference 15 - 3 = 12
+// the distance is index 4 - 1 + 1 = 4
+
+// console.log(minSubArrayLen(11, [1,2,3,4,5]));

282 Expression Add Operators.js

@@ -0,0 +1,52 @@
+// Given a string that contains only digits 0-9 and a target value, return all possibilities to add binary operators (not unary) +, -, or * between the digits so they evaluate to the target value.
+
+// Examples: 
+// "123", 6 -> ["1+2+3", "1*2*3"] 
+// "232", 8 -> ["2*3+2", "2+3*2"]
+// "105", 5 -> ["1*0+5","10-5"]
+// "00", 0 -> ["0+0", "0-0", "0*0"]
+// "3456237490", 9191 -> []
+// Credits:
+// Special thanks to @davidtan1890 for adding this problem and creating all test cases.
+
+// Hide Company Tags Google Facebook
+// Hide Tags Divide and Conquer
+// Hide Similar Problems (M) Evaluate Reverse Polish Notation (H) Basic Calculator (M) Basic Calculator II (M) Different Ways to Add Parentheses
+
+
+// reference: http://blog.csdn.net/pointbreak1/article/details/48596115
+
+var addOperators = function(num, target) {
+  function opRecur(num, target, lastOp, result, expression, results) {
+    if(num.length === 0) {
+      if(target === result) {
+        results.push(expression);
+      }
+      return;
+    }
+
+    for(var i = 1; i <= num.length; i++) {
+      var curr = num.substring(0, i);
+      if(curr.length > 1 && curr[0] === '0') {
+        continue;
+      }
+
+      var rest = num.substring(i);
+      var currVal = parseInt(curr);
+
+      if(expression.length === 0) {
+        opRecur(rest, target, currVal, currVal, expression + curr, results);
+      } else {
+        opRecur(rest, target, currVal, result + currVal, expression + "+" + curr, results);  
+        opRecur(rest, target,-currVal, result - currVal, expression + "-" + curr, results);  
+        opRecur(rest, target, currVal * lastOp, result - lastOp + lastOp * currVal, expression + "*" + curr, results);  
+      }
+    }
+  }
+
+  var results = [];
+  opRecur(num, target, 0, 0, '', results);
+  return results;
+};
+
+console.log(addOperators('01023', 3));

311 Sparse Matrix Multiplication.js

@@ -0,0 +1,97 @@
+// Given two sparse matrices A and B, return the result of AB.
+
+// You may assume that A's column number is equal to B's row number.
+
+// Example:
+
+// A = [
+//   [ 1, 0, 0],
+//   [-1, 0, 3]
+// ]
+
+// B = [
+//   [ 7, 0, 0 ],
+//   [ 0, 0, 0 ],
+//   [ 0, 0, 1 ]
+// ]
+
+
+//      |  1 0 0 |   | 7 0 0 |   |  7 0 0 |
+// AB = | -1 0 3 | x | 0 0 0 | = | -7 0 3 |
+//                   | 0 0 1 |
+// Hide Company Tags LinkedIn Facebook
+// Hide Tags Hash Table
+
+
+/**
+ * @param {number[][]} A
+ * @param {number[][]} B
+ * @return {number[][]}
+ */
+
+// normal matrix mulitplication
+// slower version
+var multiply = function(A, B) {
+    var result = [];
+
+    var rowA = A.length;
+    var colA = A[0].length;
+    var rowB = B.length;
+    var colB = B[0].length
+
+    for(var i = 0; i < rowA; i++) {
+        result.push(Array(colB).fill(0));
+        
+        for(var j = 0; j < colB; j++) {
+            
+            for(var k = 0; k < colA; k++) {
+                result[i][j] += A[i][k]*B[k][j]    
+            }
+            
+        }
+    }
+    
+    return result;
+};
+
+// faster
+// skip
+multiply = function(A, B) {
+    var result = [];
+    var i,j,k;
+
+    var rowA = A.length;
+    var colA = A[0].length;
+    var colB = B[0].length
+
+    for(var i = 0; i < rowA; i++) {
+        result.push(Array(colB).fill(0));
+    }
+
+    for(i = 0; i < rowA; i++) {
+        for(k = 0; k < colA; k++) {
+            if(A[i][k] !== 0) {
+                for(j = 0; j < colB; j++) {
+                    if(B[k][j] !== 0) {
+                        result[i][j] += A[i][k]*B[k][j];
+                    }
+                }    
+            }
+        }
+    }
+    
+    return result;
+};
+
+
+
+// var data1 = [[0,1],[0,0],[0,1]];
+// var data2 = [[1,0],[1,0]];
+
+// var data1 = [[1,0,0],[-1,0,3]];
+// var data2 = [[7,0,0],[0,0,0],[0,0,1]];
+
+var data1 = [[1,-5]];
+var data2 = [[12],[-1]];
+
+console.log(multiply(data1,data2));

325 Maximum Size Subarray Sum Equals k.js

@@ -0,0 +1,44 @@
+// Given an array nums and a target value k, find the maximum length of a subarray that sums to k. If there isn't one, return 0 instead.
+
+// Example 1:
+// Given nums = [1, -1, 5, -2, 3], k = 3,
+// return 4. (because the subarray [1, -1, 5, -2] sums to 3 and is the longest)
+
+// Example 2:
+// Given nums = [-2, -1, 2, 1], k = 1,
+// return 2. (because the subarray [-1, 2] sums to 1 and is the longest)
+
+// Follow Up:
+// Can you do it in O(n) time?
+
+// Hide Company Tags Palantir Facebook
+// Hide Tags Hash Table
+// Hide Similar Problems (M) Minimum Size Subarray Sum (E) Range Sum Query - Immutable
+
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var maxSubArrayLen = function(nums, k) {
+    var maxLen = 0;
+    var currSum = 0;
+    var dict = { 0: -1 };
+    
+    for(var i = 0; i < nums.length; i++) {
+        currSum += nums[i];
+        
+        // since we are looking for the maxlen, dict is used to store the very first
+        // location where currSum occurred      
+        if(dict[currSum] === undefined) {
+            dict[currSum] = i;
+        }
+        
+        if(dict[currSum - k] !== undefined) {
+            maxLen = Math.max(maxLen, i - dict[currSum - k]);
+        }
+    }
+    
+    return maxLen;
+};

43 Multiply Strings.js

@@ -1,44 +1,52 @@
+// Given two numbers represented as strings, return multiplication of the numbers as a string.
+
+// Note:
+// The numbers can be arbitrarily large and are non-negative.
+// Converting the input string to integer is NOT allowed.
+// You should NOT use internal library such as BigInteger.
+// Hide Company Tags Facebook Twitter
+// Hide Tags Math String
+// Hide Similar Problems (M) Add Two Numbers (E) Plus One (E) Add Binary
+
 /**
  * @param {string} num1
  * @param {string} num2
  * @return {string}
  */
 var multiply = function(num1, num2) {
-    if(num1 === null || num2 === null || num1.length === 0 || num2.length === 0){
-        return 0;
+    if(num1 === null || num2 === null || num1.length === 0 || num2.length === 0 || num1 === '0' || num2 === '0') {
+        return '0';
     }
 
     var arr1 = num1.split('').reverse();
     var arr2 = num2.split('').reverse();
-    
     var result = [];
 
-    for(var i = 0; i < arr1.length; i++){
+    for(var i = 0; i < arr1.length; i++) {
         var carry = 0;
+        var val1 = parseInt(arr1[i]);
 
-        for(var j = 0; j < arr2.length; j++){
-            var n1 = parseInt(arr1[i]);
-            var n2 = parseInt(arr2[j]);
-            var exist = parseInt(result[i+j] || 0);
-            var total = n1*n2+carry+exist;
-            
-            var remain = total%10 + '';
-            carry = parseInt(total/10);
-            result[i+j] = remain;
+        for(var j = 0; j < arr2.length; j++) {
+            var val2 = parseInt(arr2[j]);
+            var product = val1*val2 + carry;
+            var exist = result[i+j] || 0;
+            var sum = product + exist;
+            var digit = sum%10;
+            carry = Math.floor(sum/10);
+            result[i+j] = digit;
         }
 
-        if(carry > 0){
-            result[i + j] = carry + '';
+        if(carry > 0) {
+            result[i+j] = carry;
         }
     }
 
-    result = result.reverse();
+    result.reverse();
     result = result.join('');
-    result = result.replace(/^0+/g,'');
+    result = result.replace(/^0+/, '');
 
-    if(result.length === 0){
-        return "0";
-    } else {
-        return result;
-    }
-};
+    
+    return result;
+};
+
+multiply('123', '456')