Add my solutions up to #695

Author: alexwawl

solutions/235_LowestCommonAncestorofaBinarySearchTree.js

@@ -0,0 +1,26 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} p
+ * @param {TreeNode} q
+ * @return {TreeNode}
+ */
+var lowestCommonAncestor = function(root, p, q) {
+    let parent_value = root.val;
+    let p_value = p.val;
+    let q_value = q.val;
+    if(p_value > parent_value && q_value > parent_value){
+        return lowestCommonAncestor(root.right,p,q)
+    } else if(p_value < parent_value && q_value < parent_value){
+        return lowestCommonAncestor(root.left,p,q)
+    } else{
+        return root
+    }
+     
+};

solutions/236_LowestCommonAncestorofaBinaryTree.js

@@ -0,0 +1,30 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} p
+ * @param {TreeNode} q
+ * @return {TreeNode}
+ */
+var lowestCommonAncestor = function(root, p, q) {
+    let result = [];
+    function helper(node){
+        if(!node){
+            return false;
+        }
+        let left = helper(node.left);
+        let right = helper(node.right);
+        let middle = node == p || node == q;
+        if(left + right + middle >= 2){
+            result.push(node)
+        }
+        return left || right || middle
+    }
+    helper(root)
+    return result[0];
+};

solutions/240_Searcha2DMatrixII.js

@@ -0,0 +1,32 @@
+/**
+ * @param {number[][]} matrix
+ * @param {number} target
+ * @return {boolean}
+ */
+var searchMatrix = function(matrix, target) {
+    function search(x1, y1, x2, y2){
+        if(x2 < x1 || y2 < y1 || x1 >= matrix.length || y1 >= matrix[0].length || y2 < 0 || x2 < 0){
+            return false;
+        }
+        let middle_x = Math.floor((x2-x1)/2) + x1;
+        let middle_y = Math.floor((y2-y1)/2) + y1;
+        let current = matrix[middle_x][middle_y];
+        if(current == target){
+            return true;
+        } else if(current < target){
+            //search in: whole down (+1 from middle WHY?) and right top (+1 from middle WHY?)
+            return search(x1, middle_y+1, x2, y2) || // whole down
+                   search(middle_x+1, y1, x2, middle_y) //
+        } else if (current > target){
+            //search in: whole up (+1 from middle WHY?) and left down (-1 from middle WHY?)
+            return search(x1, y1, x2, middle_y-1) || // whole up
+                    search(x1, middle_y, middle_x-1,y2)
+        } else {
+            return false;
+        }
+    }
+    if(matrix.length === 0 || matrix[0].length === 0){
+        return false
+    }
+    return search(0, 0 , matrix.length-1, matrix[0].length-1)
+};

solutions/240_Searcha2DMatrixII.py

@@ -0,0 +1,30 @@
+class Solution(object):
+    def searchMatrix(self, matrix, target):
+        """
+        :type matrix: List[List[int]]
+        :type target: int
+        :rtype: bool
+        """
+        if len(matrix) == 0 or len(matrix[0])==0:
+            return False
+        return self.search(0,0,len(matrix)-1, len(matrix[0])-1, matrix, target)
+    
+    def search(self, x1, y1, x2, y2, matrix, target):
+        if x2 < x1 or y2 < y1 or x1 >= len(matrix) or y1 >= len(matrix[0]) or x2 < 0 or y2 < 0:
+            return False
+        
+        middle_x = x1 + (x2-x1) // 2
+        middle_y = y1 + (y2-y1) // 2
+        
+        current = matrix[middle_x][middle_y]
+        
+        if current == target:
+            return True
+        elif current < target:
+            return (self.search(x1, middle_y+1, x2, y2, matrix, target) or 
+                        self.search(middle_x+1, y1, x2, middle_y, matrix, target))
+        elif current > target:
+            return (self.search(x1, y1, x2, middle_y-1, matrix, target) or 
+                       self.search(x1, middle_y, middle_x-1, y2, matrix, target))
+        else:
+            return False

solutions/242_ValidAnagram.js

@@ -0,0 +1,29 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+var isAnagram = function(s, t) {
+    if(s.length != t.length){
+        return false
+    }
+    let dict = {};
+    for(let i = 0 ;i<s.length;i++){
+        if(dict[s[i]]){
+            dict[s[i]]++
+        } else {
+            dict[s[i]] = 1
+        }
+    }
+    for(let j = 0; j<t.length;j++){
+        if(dict[t[j]]){
+            dict[t[j]]--;
+            if(dict[t[j]] <= 0){
+                delete dict[t[j]]
+            }
+        } else {
+            return false
+        }
+    }
+    return true
+};

solutions/257_BinaryTreePath.js

@@ -0,0 +1,32 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {string[]}
+ */
+var binaryTreePaths = function(root) {
+    let result = [];
+    if(!root){
+        return []
+    }
+    function helper(root, current){
+        if(!root.left && !root.right){
+            result.push(current + root.val);
+            return;
+        }
+        if(root.left){
+            helper(root.left,current+root.val+'->')
+        }
+        if(root.right){
+            helper(root.right,current+root.val+'->')
+        }
+       
+    }
+    helper(root,'');
+    return result
+};

solutions/283_MoveZeros.js

@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @return {void} Do not return anything, modify nums in-place instead.
+ */
+var moveZeroes = function(nums) {
+    let j = 0
+    for (let i = 0; i<nums.length;i++){
+        if(nums[i]!==0){
+            let tmp = nums[i]
+            nums[i] = nums[j]
+            nums[j] = tmp
+            j++
+        }
+    }
+};

solutions/287_FindtheDuplicateNumber.js

@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findDuplicate = function(nums) {
+    let dict = {}
+    for(let i = 0; i<nums.length;i++){
+        if(dict[nums[i]]){
+            return nums[i]
+        } else {
+            dict[nums[i]] = true
+        }
+    }
+    return -1
+};

solutions/289_GameofLife.js

@@ -0,0 +1,53 @@
+/**
+ * @param {number[][]} board
+ * @return {void} Do not return anything, modify board in-place instead.
+ */
+var gameOfLife = function(board) {
+    let rows = board.length;
+    let cols = board[0].length;
+    function initMatrix(rows,cols){
+        let newMatrix = [];
+        for(let i=0;i<rows;i++){
+            newMatrix[i] = []
+        }
+        return newMatrix;
+    }
+    function getCurrentState(board,curr_i,curr_j){
+        let start_i = curr_i-1 > 0 ? curr_i-1 : 0;
+        let start_j = curr_j-1 > 0 ? curr_j-1:0;
+        let end_i = curr_i+1 < board.length-1? curr_i+1 : board.length-1;
+        let end_j = curr_j+1 < board[0].length-1? curr_j+1 : board[0].length-1;
+        let neighbors_cnt = 0;
+        for(let i = start_i; i<=end_i;i++){
+            for(let j = start_j;j<=end_j;j++){
+                if(board[i][j]==1){
+                    neighbors_cnt++
+                }
+            }
+        }
+        let next_element = undefined;
+        let current_element = board[curr_i][curr_j]
+        if(current_element == 1){
+            //because we can count ourself
+            neighbors_cnt = neighbors_cnt -1;
+            next_element = (neighbors_cnt > 3 || neighbors_cnt < 2) ? 0 : 1;
+        } else {
+            next_element = neighbors_cnt === 3 ? 1: current_element;
+        }
+       return next_element;
+    }
+    
+    let new_matrix = initMatrix(rows,cols);
+    for(let i = 0;i<rows;i++){
+        for(let j =0;j<cols;j++){
+            new_matrix[i][j] = getCurrentState(board,i,j);
+        }
+    }
+    
+    //copying new_matrix to board
+    for(let i = 0;i<rows;i++){
+        for(let j = 0;j<cols;j++){
+            board[i][j] = new_matrix[i][j]
+        }
+    }
+};

solutions/297_SerializeandDeserializeBinaryTree.js

@@ -0,0 +1,56 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+
+/**
+ * Encodes a tree to a single string.
+ *
+ * @param {TreeNode} root
+ * @return {string}
+ */
+var serialize = function(root) {
+    let result = []
+    function helper(root){
+        if(!root){
+            result.push("#")
+        } else {
+            result.push(root.val);
+            helper(root.left)
+            helper(root.right)
+        }
+    }
+    helper(root)
+    return result.toString();
+};
+
+/**
+ * Decodes your encoded data to tree.
+ *
+ * @param {string} data
+ * @return {TreeNode}
+ */
+var deserialize = function(data) {
+    let arr = data.split(',');
+    var index = 0;
+    function helper(arr){
+        if(arr[index] == '#' || index > arr.length){
+            return null;
+        }
+        let root = new TreeNode(parseInt(arr[index]));
+        index = index + 1;
+        root.left = helper(arr);
+        index = index + 1;
+        root.right = helper(arr)
+        return root
+    }
+    return helper(arr)
+};
+
+/**
+ * Your functions will be called as such:
+ * deserialize(serialize(root));
+ */

solutions/300_LongestIncreasingSubsequence.js

@@ -0,0 +1,35 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var lengthOfLIS = function(nums) {
+    let dp = new Array(nums.length).fill(0);
+    dp[0] = 1;
+    let result = 1;
+    if(nums.length == 0){
+        return 0
+    }
+    // in dp contains all subsequence length;
+    // [10,9,2,5,3,7,101,18]
+    // [1,0,0,0,0,0,0,0] // step 1
+    // [1,1,0,0,0,0,0,0] // step 2. 9 < 10 so numbers are not growing.
+    // [1,1,1,0,0,0,0,0] // step 3. 2 < 10 || 9 so numbers are not growing.
+    // [1,1,1,2,0,0,0,0] // step 4. 5 > 2 -> dp[indexOf(2)  == 2] == 1; dp[i] = 1 + 1(beucase 1 more element in sequense)
+    // [1,1,1,2,2,0,0,0] // step 5. 3 > 2 -> dp[indexOf(2) == 2] == 1; dp[i] = 1 + 1
+    // [1,1,1,2,2,3,0,0] // step 6. 7 > 3 -> dp[indexOf(3) == 4] == 2; dp[i] = 2 + 1;
+    // [1,1,1,2,2,3,4,0] // step 7. 101 > 7 -> dp[indexOf(7) == 5] == 3; dp[i] = 3 + 1;
+    // [1,1,1,2,2,3,4,4] // step 8. 10 > 7 -> dp[indexOf(7) == 5] == 3; dp[i] = 3+1;
+    // If we have array like [10,9,2,5,3,7,101,102]; then
+    // [1,1,1,2,2,3,4,4,5] // step 9 102 > 101; dp[indexOf(101) == 6] == 4; dp[i] = 4 +1;
+    for(let i = 1;i<nums.length;i++){
+        let max_length = 0
+        for(let j = 0; j<i;j++){
+            if(nums[i] > nums[j]){
+                max_length = Math.max(max_length, dp[j])
+            }
+        }
+        dp[i] = max_length + 1;
+        result = Math.max(dp[i], result);
+    }
+    return result
+};