add more solution

Author: chihungyu1116

101 Symmetric Tree.js

@@ -1,3 +1,26 @@
+// Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).
+
+// For example, this binary tree [1,2,2,3,4,4,3] is symmetric:
+
+//     1
+//    / \
+//   2   2
+//  / \ / \
+// 3  4 4  3
+// But the following [1,2,2,null,3,null,3] is not:
+//     1
+//    / \
+//   2   2
+//    \   \
+//    3    3
+// Note:
+// Bonus points if you could solve it both recursively and iteratively.
+
+// Hide Company Tags LinkedIn Bloomberg Microsoft
+// Hide Tags Tree Depth-first Search Breadth-first Search
+
+
+
 /**
  * Definition for a binary tree node.
  * function TreeNode(val) {
@@ -10,55 +33,42 @@
  * @return {boolean}
  */
 var isSymmetric = function(root) {
-    if(root === null){
-        return true;
-    }
-    
     var queue = [];
     queue.push(root);
 
-    var temp = [];
-    var curCnt = 1;
-    var nextCnt = 0;
-
-    while(queue.length !== 0){
-        var p = queue.shift();
+    while(queue.length !== 0) {
+        var len = queue.length;
 
-        if(p !== null){
-            temp.push(p.left);
-            temp.push(p.right);
+        if(!isLevelSymmetric(queue)) {
+            return false;
         }
 
-        if(queue.length === 0){
-            if(isPalindrome(temp)){
-                queue = temp;
-                temp = [];
-            } else {
-                return false;
+        for(var i = 0; i < len; i++) {
+            var node = queue.shift();
+            
+            if(node !== null) {
+                queue.push(node.left);
+                queue.push(node.right);
             }
         }
     }
 
     return true;
 };
 
-
-var isPalindrome = function(arr){
-    var head = 0;
-    var tail = arr.length - 1;
+function isLevelSymmetric(nodes) {
+    var len = nodes.length;
+    var beg = 0;
+    var end = len - 1;
 
-    while(head < tail){
-        if(arr[head] && arr[tail]){
-            if(arr[head].val !== arr[tail].val){
-                return false;
-            }
-        } else if(arr[head] || arr[tail]){
+    while(beg < end) {
+        if(nodes[beg] === null && nodes[end] === null || (nodes[beg] && nodes[end] && nodes[beg].val === nodes[end].val)) {
+            beg++;
+            end--;
+        } else {
             return false;
         }
-        
-        head++;
-        tail--;
     }
 
     return true;
-}
+}

150 Evaluate Reverse Polish Notation.js

@@ -1,37 +1,42 @@
-// Leetcode #150
-// Language: Javascript
-// Problem: https://leetcode.com/problems/evaluate-reverse-polish-notation/
-// Author: Chihung Yu
+// Evaluate the value of an arithmetic expression in Reverse Polish Notation.
+
+// Valid operators are +, -, *, /. Each operand may be an integer or another expression.
+
+// Some examples:
+//   ["2", "1", "+", "3", "*"] -> ((2 + 1) * 3) -> 9
+//   ["4", "13", "5", "/", "+"] -> (4 + (13 / 5)) -> 6
+// Hide Company Tags LinkedIn
+// Hide Tags Stack
+// Hide Similar Problems (H) Basic Calculator (H) Expression Add Operators
+
 /**
  * @param {string[]} tokens
  * @return {number}
  */
 var evalRPN = function(tokens) {
     var stack = [];
 
-    for(var i = 0; i < tokens.length; i++){
-        var t = tokens[i];
-        
-        if(t === '+'){
-            var x = parseInt(stack.pop());
-            var y = parseInt(stack.pop());
-            stack.push(x + y);
-        } else if(t === '-'){
-            x = parseInt(stack.pop());
-            y = parseInt(stack.pop());
-            stack.push(y - x);
-        } else if(t === '*'){
-            x = parseInt(stack.pop());
-            y = parseInt(stack.pop());
-            stack.push(parseInt(y * x));
-        } else if(t === '/'){
-            x = parseInt(stack.pop());
-            y = parseInt(stack.pop());
-            stack.push(parseInt(y / x));
+    for(var i = 0; i < tokens.length; i++) {
+        var token = tokens[i];
+        var val1,val2;
+        var val = parseInt(token);
+        if(!isNaN(val)) {
+            stack.push(val);
         } else {
-            stack.push(t);
+            val2 = stack.pop();
+            val1 = stack.pop();
+            
+            if(token === '*') {
+                stack.push(parseInt(val1 * val2));
+            } else if(token === '/') {
+                stack.push(parseInt(val1 / val2));
+            } else if(token === '-') {
+                stack.push(val1 - val2);
+            } else if(token === '+') {
+                stack.push(val1 + val2);
+            }
         }
     }
-    var num = stack.pop();
-    return parseInt(num);
+    
+    return stack.pop();
 };

152 Maximum Product Subarray.js

@@ -1,12 +1,22 @@
+// Find the contiguous subarray within an array (containing at least one number) which has the largest product.
+
+// For example, given the array [2,3,-2,4],
+// the contiguous subarray [2,3] has the largest product = 6.
+
+// Hide Company Tags LinkedIn
+// Hide Tags Array Dynamic Programming
+// Show Similar Problems
+
+
+
 // Leetcode #152
 // Language: Javascript
 // Problem: https://leetcode.com/problems/maximum-product-subarray/
-// Author: Chihung Yu
 /**
  * @param {number[]} nums
  * @return {number}
  */
-//  http://www.programcreek.com/2014/03/leetcode-maximum-product-subarray-java/
+// reference: http://www.programcreek.com/2014/03/leetcode-maximum-product-subarray-java/
 var maxProduct = function(nums) {
   if(nums === null || nums.length === 0){
       return 0;

156 Binary Tree Upside Down.js

@@ -0,0 +1,86 @@
+// Given a binary tree where all the right nodes are either leaf nodes with a sibling (a left node that shares the same parent node) or empty, flip it upside down and turn it into a tree where the original right nodes turned into left leaf nodes. Return the new root.
+
+// For example:
+// Given a binary tree {1,2,3,4,5},
+//     1
+//    / \
+//   2   3
+//  / \
+// 4   5
+// return the root of the binary tree [4,5,2,#,#,3,1].
+//    4
+//   / \
+//  5   2
+//     / \
+//    3   1  
+// confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.
+
+// Hide Company Tags LinkedIn
+// Hide Tags Tree
+// Show Similar Problems
+
+
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {TreeNode}
+ */
+var upsideDownBinaryTree = function(root) {
+    var newRoot = root;
+    
+    generateUpsideDownHelper(root);
+    
+    function generateUpsideDownHelper(root) {
+        if(!root) {
+            return root;
+        }
+        
+        if(!root.left && !root.right) {
+            newRoot = root;
+            return root;
+        }
+    
+        if(root.left) {
+            var ret = generateUpsideDownHelper(root.left);
+            ret.left = root.right;
+            ret.right = root;
+            root.left = null;
+            root.right = null;
+        }
+        
+        return root;
+    }
+    return newRoot;
+};
+
+
+// simpler solution
+var upsideDownBinaryTree = function(root) {
+    // second condition ensure the left most child will be the new root
+    if (!root || (!root.left && !root.right)) {
+        return root;
+    }
+    
+    let newRoot = upsideDownBinaryTree(root.left);
+    console.log(newRoot.val, root.left)
+    
+    root.left.left = root.right;
+    root.left.right = root;
+
+    // cannot work if we sub root.left with newRoot
+    // since new root is always the left most child
+    // [doesn't work] newRoot.left = root.right;
+    // [doesn't work] newRoot.right = root;
+    
+    root.left = null;
+    root.right = null;
+    
+    return newRoot;
+};

187 Repeated DNA Sequences.js

@@ -0,0 +1,34 @@
+// All DNA is composed of a series of nucleotides abbreviated as A, C, G, and T, for example: "ACGAATTCCG". When studying DNA, it is sometimes useful to identify repeated sequences within the DNA.
+
+// Write a function to find all the 10-letter-long sequences (substrings) that occur more than once in a DNA molecule.
+
+// For example,
+
+// Given s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT",
+
+// Return:
+// ["AAAAACCCCC", "CCCCCAAAAA"].
+// Hide Company Tags LinkedIn
+// Hide Tags Hash Table Bit Manipulation
+
+
+/**
+ * @param {string} s
+ * @return {string[]}
+ */
+var findRepeatedDnaSequences = function(s) {
+    var hash = {};
+    var result = [];
+    
+    for(var i = 10; i <= s.length; i++) {
+        var substr = s.substring(i - 10, i);
+        if(hash[substr] === undefined) {
+            hash[substr] = 1;
+        } else if(hash[substr] === 1) {
+            hash[substr]++;
+            result.push(substr);
+        }
+    }
+    
+    return result;
+};

236 Lowest Common Ancestor of a Binary Tree.js

@@ -30,8 +30,12 @@
  * @param {TreeNode} q
  * @return {TreeNode}
  */
+
+// Amazon LinkedIn Apple Facebook Microsoft
+// Hide Tags Tree
+// Hide Similar Problems
 
-//  http://www.cnblogs.com/anne-vista/p/4815076.html
+// reference: http://www.cnblogs.com/anne-vista/p/4815076.html
 var lowestCommonAncestor = function(root, p, q) {
     if(root === null || root === p || root === q) {
         return root;