add more solutions

Author: chihungyu1116

150 Evaluate Reverse Polish Notation.js

@@ -39,4 +39,7 @@ var evalRPN = function(tokens) {
     }
 
     return stack.pop();
-};
+};
+
+
+console.log(evalRPN([ 12, 12, 12, '*', '+', 3, 4, '-', '+' ] ));

170 Two Sum III - Data structure design.js

@@ -0,0 +1,45 @@
+/**
+ * initialize your data structure here
+ * @constructor
+ */
+var TwoSum = function() {
+    this.hashmap = new Map();
+};
+
+/**
+ * Add the number to an internal data structure.
+ * @param {number} input
+ * @returns {void}
+ */
+TwoSum.prototype.add = function(input) {
+    this.hashmap[input] = this.hashmap[input] || 0;
+    this.hashmap[input]++;
+};
+
+/**
+ * Find if there exists any pair of numbers which sum is equal to the value.
+ * @param {number} val
+ * @returns {boolean}
+ */
+TwoSum.prototype.find = function(val) {  
+    for(var key in this.hashmap) {
+        var diff = val - parseInt(key);
+
+        if(diff === parseInt(key)){
+          if(this.hashmap[diff] >= 2) {
+            return true;
+          }
+        } else if(this.hashmap[diff] >= 1) {
+            return true;
+        }
+    }
+    
+    return false;
+};
+
+/**
+ * Your TwoSum object will be instantiated and called as such:
+ * var twoSum = new TwoSum();
+ * twoSum.add(number);
+ * twoSum.find(value);
+ */

205 Isomorphic Strings.js

@@ -1,36 +1,49 @@
-// Leetcode #205
-// Language: Javascript
-// Problem: https://leetcode.com/problems/isomorphic-strings/
-// Author: Chihung Yu
+// Given two strings s and t, determine if they are isomorphic.
+
+// Two strings are isomorphic if the characters in s can be replaced to get t.
+
+// All occurrences of a character must be replaced with another character while preserving the order of characters. No two characters may map to the same character but a character may map to itself.
+
+// For example,
+// Given "egg", "add", return true.
+
+// Given "foo", "bar", return false.
+
+// Given "paper", "title", return true.
+
+// Note:
+// You may assume both s and t have the same length.
+
+// Hide Company Tags LinkedIn
+// Hide Tags Hash Table
+// Hide Similar Problems (E) Word Pattern
+
+
+
 /**
  * @param {string} s
  * @param {string} t
  * @return {boolean}
  */
 var isIsomorphic = function(s, t) {
-    if(s === null || t === null){
-        return true;
+    if(s.length !== t.length) {
+        return false;
     }
 
     var hash1 = {};
     var hash2 = {};
 
-    for(var i = 0; i < s.length; i++){
-        var sc = s[i];
-        var tc = t[i];
-        
-        hash1[sc] = tc;
-        hash2[tc] = sc;
+    for(var i = 0; i < s.length; i++) {
+        hash1[s[i]] = t[i];
+        hash2[t[i]] = s[i];
     }
 
-    var result1 = "";
-    var result2 = "";
+    var result1 = '';
+    var result2 = '';
 
-    for(i = 0; i < s.length; i++){
-        sc = s[i]
-        tc = t[i];
-        result1 += hash1[sc];
-        result2 += hash2[tc];
+    for(i = 0; i < s.length; i++) {
+        result1 += hash1[s[i]];
+        result2 += hash2[t[i]];
     }
 
     return result1 === t && result2 === s;

224 Basic Calculator.js

@@ -18,39 +18,102 @@ Note: Do not use the eval built-in library function.
  * @param {string} s
  * @return {number}
  */
-var calculate = function(s) {
-    var stack = [],
-        len = s.length,
-        sum = 0,
-        num,
-        ch,
-        j,
-        i;
+// var calculate = function(s) {
+//     var stack = [],
+//         len = s.length,
+//         sum = 0,
+//         num,
+//         ch,
+//         j,
+//         i;
 
-    stack.push(1);
-    stack.push(1);
+//     stack.push(1);
+//     stack.push(1);
 
-    for (i = 0; i < len; i++) {
-        ch = s.charAt(i);
+//     for (i = 0; i < len; i++) {
+//         ch = s.charAt(i);
 
-        if (!isNaN(parseInt(ch))) {
-            num = parseInt(ch);
+//         if (!isNaN(parseInt(ch))) {
+//             num = parseInt(ch);
 
-            for (j = i + 1; j < len && !isNaN(parseInt(s.charAt(j))); j++) {
-                num = num * 10 + parseInt(s.charAt(j));
-            }
+//             for (j = i + 1; j < len && !isNaN(parseInt(s.charAt(j))); j++) {
+//                 num = num * 10 + parseInt(s.charAt(j));
+//             }
 
-            sum += stack.pop() * num;
+//             sum += stack.pop() * num;
 
-            i = j - 1;
-        } else if (ch === '+' || ch === '(') {
-            stack.push(stack[stack.length - 1]);
-        } else if (ch === '-') {
-            stack.push(stack[stack.length - 1] * (-1));
-        } else if (ch === ')') {
-            stack.pop();
+//             i = j - 1;
+//         } else if (ch === '+' || ch === '(') {
+//             stack.push(stack[stack.length - 1]);
+//         } else if (ch === '-') {
+//             stack.push(stack[stack.length - 1] * (-1));
+//         } else if (ch === ')') {
+//             stack.pop();
+//         }
+//     }
+    
+//     return sum;
+// };
+
+
+
+/**
+Implement a basic calculator to evaluate a simple expression string.
+
+The expression string may contain open ( and closing parentheses ), the plus + or minus sign -, non-negative integers and empty spaces .
+
+You may assume that the given expression is always valid.
+
+Some examples:
+"1 + 1" = 2
+" 2-1 + 2 " = 3
+"(1+(4+5+2)-3)+(6+8)" = 23
+Note: Do not use the eval built-in library function.
+*/
+/**
+ * @param {string} s
+ * @return {number}
+ */
+
+
+
+console.log(calculate("10+20-((2-4)*6-5)*6"));
+var calculate = function(s) {
+
+
+
+
+
+}
+
+function helper(s, i, sign, finalSum, currentSum) {
+    while(i < s.length) {
+        if(s[i].match(/[0-9]/)) {
+            var num = 0;
+
+            while(i < s.length) {
+                if(s[i].match(/[0-9]/)) {
+                    num *= 10;
+                    num += parseInt(s[i]);
+                    i++                    
+                } else {
+                    break;
+                }
+            }
+        } else if(s[i] === '-') {
+
+        } else if(s[i] === '+') {
+            return num + helper(s, i, sign, finalSum, currentSum);
+        } else if(s[i] === '*') {
+
+        } else if(s[i] === '/') {
+
+        } else if(s[i] === '(') {
+
+        } else if(s[i] === ')') {
+
         }
+
+        i++;
     }
-    
-    return sum;
-};
+}

261 Graph Valid Tree.js

@@ -32,7 +32,7 @@ var validTree = function(n, edges) {
         }
     }
 
-    return unionFind.unionCount() === 1;
+    return unionFind.count() === 1;
 };
 
 // reference: http://blog.csdn.net/dm_vincent/article/details/7655764
@@ -75,7 +75,7 @@ class UnionFind {
         return this.find(m) === this.find(n);
     }
 
-    unionCount() {
+    count() {
         return this.count;
     }
 }

349 Intersection of Two Arrays.js

@@ -0,0 +1,43 @@
+// Given two arrays, write a function to compute their intersection.
+
+// Example:
+// Given nums1 = [1, 2, 2, 1], nums2 = [2, 2], return [2].
+
+// Note:
+// Each element in the result must be unique.
+// The result can be in any order.
+// Hide Tags Binary Search Hash Table Two Pointers Sort
+// Hide Similar Problems (E) Intersection of Two Arrays II
+
+
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number[]}
+ */
+var intersection = function(nums1, nums2) {
+    var hash = {};
+    var result = [];
+    var i = 0;
+    while(i < nums1.length || i < nums2.length) {
+        if(i < nums1.length) {
+            hash[nums1[i]] = hash[nums1[i]] || [];
+            hash[nums1[i]][0] = true;
+        }
+        
+        if(i < nums2.length) {
+            hash[nums2[i]] = hash[nums2[i]] || [];
+            hash[nums2[i]][1] = true;
+        }
+
+        i++
+    }
+    
+    for(i in hash) {
+        if(hash[i][0] && hash[i][1]) {
+            result.push(parseInt(i));
+        }
+    }
+    
+    return result;
+};

350 Intersection of Two Arrays II.js

@@ -0,0 +1,52 @@
+// Given two arrays, write a function to compute their intersection.
+
+// Example:
+// Given nums1 = [1, 2, 2, 1], nums2 = [2, 2], return [2, 2].
+
+// Note:
+// Each element in the result should appear as many times as it shows in both arrays.
+// The result can be in any order.
+// Follow up:
+// What if the given array is already sorted? How would you optimize your algorithm?
+// What if nums1's size is small compared to nums2's size? Which algorithm is better?
+// What if elements of nums2 are stored on disk, and the memory is limited such that you cannot load all elements into the memory at once?
+// Hide Tags Binary Search Hash Table Two Pointers Sort
+// Hide Similar Problems (E) Intersection of Two Arrays
+
+
+
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number[]}
+ */
+var intersect = function(nums1, nums2) {
+    var hash = {};
+    var arr1, arr2;
+
+    if(nums1.length > nums2.length) {
+        arr1 = nums2;
+        arr2 = nums1;
+    } else {
+        arr1 = nums1;
+        arr2 = nums2;
+    }
+
+    var count = arr1.length;
+    var result = [];
+    
+    for(var i = 0; i < arr1.length; i++) {
+        hash[arr1[i]] = hash[arr1[i]] || 0;
+        hash[arr1[i]]++;
+    }
+    
+    for(i = 0; i < arr2.length && count !== 0; i++) {
+        if(hash[arr2[i]] > 0) {
+            hash[arr2[i]]--;
+            count--;
+            result.push(arr2[i]);
+        }
+    }
+    
+    return result;
+};