add more

Author: chihungyu1116

112 Path Sum.js

@@ -24,4 +24,31 @@ var hasPathSum = function(root, sum) {
     }
 
     return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
+};
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} sum
+ * @return {boolean}
+ */
+var hasPathSum = function(root, sum) {
+    if (root === null) {
+        return false;
+    }
+    
+    var left = root.left;
+    var right = root.right;
+    
+    if (left === null && right === null) {
+        return root.val === sum;
+    }
+    
+    return hasPathSum(left, sum - root.val) || hasPathSum(right, sum - root.val);
 };

141 Linked List Cycle.js

@@ -2,6 +2,44 @@
 // Language: Javascript
 // Problem: https://leetcode.com/problems/linked-list-cycle/
 // Author: Chihung Yu
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+
+/**
+ * @param {ListNode} head
+ * @return {boolean}
+ */
+// var hasCycle = function(head) {
+//     if(head === null || head.next === null){
+//         return false;
+//     }
+    
+//     var faster = head.next;
+//     var slower = head;
+    
+//     while(faster && slower){
+//         if(faster.val === slower.val){
+//             return true;
+//         }
+//         faster = faster.next;
+        
+//         if(faster === null){
+//             return false;
+//         } else {
+//             faster = faster.next;
+//         }
+        
+//         slower = slower.next;
+//     }
+    
+//     return false;
+// };
+
 /**
  * Definition for singly-linked list.
  * function ListNode(val) {
@@ -15,26 +53,27 @@
  * @return {boolean}
  */
 var hasCycle = function(head) {
-    if(head === null || head.next === null){
+    if (head === null) {
         return false;
     }
+
+    var node1 = head;
+    var node2 = head;
+    node2 = node2.next;
 
-    var faster = head.next;
-    var slower = head;
-    
-    while(faster && slower){
-        if(faster.val === slower.val){
+    while(node1 !== null && node2 !== null) {
+        if (node1.val === node2.val) {
             return true;
         }
-        faster = faster.next;
+
+        node1 = node1.next;
+        node2 = node2.next;
 
-        if(faster === null){
-            return false;
-        } else {
-            faster = faster.next;
+        if (node2 !== null) {
+            node2 = node2.next;
         }
 
-        slower = slower.next;
+        
     }
 
     return false;

190 Reverse Bits.js

@@ -9,11 +9,15 @@
 var reverseBits = function(n) {
     var result =  0;
 
-    for(var i = 0; i < 32; i++){
+    for(var i = 0; i < 31; i++){
         result <<= 1;
         result |= n & 1;
-        n >>= 1;
+
+        n >>>= 1;
+        console.log(result, n);
     }
 
     return Math.abs(result);
-};
+};
+
+console.log(reverseBits(4294967295));

242 Valid Anagram.js

@@ -38,4 +38,43 @@ var isAnagram = function(s, t) {
    }
 
    return true;
+};
+
+
+
+
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+var isAnagram = function(s, t) {
+    if (s === null || t === null || s.length !== t.length) {
+        return false;
+    }
+    
+    var hash = {};
+    var i; 
+    for(i = 0; i < s.length; i++) {
+        var sval = s[i];
+        var tval = t[i];
+        
+        if (hash[sval] === undefined) {
+            hash[sval] = 0;
+        }
+        
+        if (hash[tval] === undefined) {
+            hash[tval] = 0;
+        }
+        hash[sval]++;
+        hash[tval]--;
+    }
+    
+    for(var j in hash) {
+        if (hash[j] !== 0) {
+            return false;
+        }
+    }
+    
+    return true;
 };

26 Remove Duplicates from Sorted Array.js

@@ -58,4 +58,25 @@ var removeDuplicates = function(nums) {
 };
 
 
-// [tricky]
+// [tricky]
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var removeDuplicates = function(nums) {
+    var hash = {};
+    var cur = 0;
+    
+    for(var i = 0; i < nums.length; i++) {
+        var num = nums[i];
+        
+        if (hash[num] === undefined) {
+            hash[num] = true;
+            nums[cur] = num;
+            cur++;
+        }
+    }
+    
+    return cur;
+};

278 First Bad Version.js

@@ -14,7 +14,7 @@
 
 /**
  * Definition for isBadVersion()
- * 
+ *
  * @param {integer} version number
  * @return {boolean} whether the version is bad
  * isBadVersion = function(version) {
@@ -35,18 +35,57 @@ var solution = function(isBadVersion) {
         var beg = 0;
         var end = n;
         var lastBad;
-        
+
         while(beg <= end) {
             var mid = beg + Math.floor((end - beg)/2);
             if(isBadVersion(mid)) {
                 // everything including and after are bad version
                 lastBad = mid;
                 end = mid - 1;
             } else {
-                beg = mid + 1; 
+                beg = mid + 1;
             }
         }
-        
+
         return lastBad;
     };
-};
+};
+
+
+
+/**
+ * Definition for isBadVersion()
+ *
+ * @param {integer} version number
+ * @return {boolean} whether the version is bad
+ * isBadVersion = function(version) {
+ *     ...
+ * };
+ */
+
+/**
+ * @param {function} isBadVersion()
+ * @return {function}
+ */
+var solution = function(isBadVersion) {
+    /**
+     * @param {integer} n Total versions
+     * @return {integer} The first bad version
+     */
+    return function(n) {
+        var left = 1;
+        var right = n;
+
+        while (left < right) {
+            var mid = left + Math.floor((right - left)/2);
+
+            if (isBadVersion(mid)) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+
+        return left;
+    };
+};

35 Search Insert Position.js

@@ -2,6 +2,37 @@
 // Language: Javascript
 // Problem: https://leetcode.com/problems/search-insert-position/
 // Author: Chihung Yu
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+// var searchInsert = function(nums, target) {
+//     var left = 0;
+//     var right = nums.length - 1;
+//
+//     while(left <= right){
+//         var mid = parseInt((left + right)/2);
+//
+//         var val = nums[mid];
+//
+//         if(val === target){
+//             return mid;
+//         } else if(val > target){
+//             right = mid - 1;
+//         } else {
+//             left = mid + 1;
+//         }
+//     }
+//
+//     if(nums[left] < target){
+//         return left + 1;
+//     } else {
+//         return left;
+//     }
+// };
+
+
 /**
  * @param {number[]} nums
  * @param {number} target
@@ -10,24 +41,22 @@
 var searchInsert = function(nums, target) {
     var left = 0;
     var right = nums.length - 1;
-    
-    while(left <= right){
-        var mid = parseInt((left + right)/2);
-        
-        var val = nums[mid];
-        
-        if(val === target){
+
+    while (left < right) {
+        var mid = left + Math.ceil((right - left)/2);
+
+        if (nums[mid] === target) {
             return mid;
-        } else if(val > target){
+        } else if (nums[mid] > target) {
             right = mid - 1;
         } else {
             left = mid + 1;
         }
     }
-    
-    if(nums[left] < target){
+
+    if (nums[left] < target) {
         return left + 1;
     } else {
         return left;
     }
-};
+}