Merge pull request neetcode-gh#3 from veer-p/main

JavaScript Solutions for 1, 11, 15, 19, 20, 21, 33, 48, 49, 53, 54, 70, 73, 98, 100, 104, 121, 125, 141, 143, 152, 153, 206, 217, 226, 238, 242, 268, 300, 572

Author: neetcode-gh

javascript/1-Two-Sum.js

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

javascript/100-Same-Tree.js

@@ -0,0 +1,18 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} p
+ * @param {TreeNode} q
+ * @return {boolean}
+ */
+var isSameTree = function(p, q) {
+    if (!p && !q) return true;
+    if (!p || !q || p.val !== q.val) return false; 
+    return isSameTree(p.right,q.right) && isSameTree(p.left, q.left);
+};

javascript/104-Maximum-Depth-of-Binary-Tree.js

@@ -0,0 +1,23 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var maxDepth = (root) => {
+    let maxDepth = 0;
+    let DFS = (node, depth) => {
+        if (!node) return maxDepth;
+        if (depth > maxDepth) maxDepth = depth;
+        DFS(node.right, depth + 1);
+        DFS(node.left, depth + 1);
+    }
+    DFS(root, 1);
+    return maxDepth;
+};

javascript/11-Container-With-Most-Water.js

@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} height
+ * @return {number}
+ */
+var maxArea = function(height) {
+    let max = 0;
+    let i = 0;
+    let j = height.length - 1;
+    
+    while (i < j) {
+        curr = (j - i) * Math.min(height[i], height[j]);
+        max = Math.max(curr, max);
+        if (height[i] > height[j]) {
+            j--;
+        } else {
+            i++;
+        }
+    }
+    return max;
+};

javascript/121-Best-Time-to-Buy-and-Sell-Stock.js

@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function(prices) {
+    let buy = prices[0];
+    let profit = 0; 
+    for (let i = 0; i < prices.length; i++) {
+        if (prices[i] < buy) {
+            buy = prices[i];
+        } else {
+            profit = Math.max(prices[i] - buy, profit);
+        }
+    }
+    return profit;
+};

javascript/125-Valid-Palindrome.js

@@ -0,0 +1,19 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isPalindrome = function(s) {
+    s = s.toLowerCase();
+    s = s.replace(/[^A-Z0-9]/gi, '');
+    
+    let i = 0
+    let j = s.length - 1;
+    
+    while (i < j) {
+        if (s[i] !== s[j]) return false;
+        
+        i++;
+        j--
+    }
+    return true;
+};

javascript/141-Linked-List-Cycle.js

@@ -0,0 +1,25 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+
+/**
+ * @param {ListNode} head
+ * @return {boolean}
+ */
+var hasCycle = function(head) {
+    let set = new Set(); 
+    while (head) {
+        if (set.has(head)) {
+            return true;
+        } else {
+            set.add(head);
+            head = head.next;
+        }
+    }
+    
+    return false;
+};

javascript/143-Reorder-List.js

@@ -0,0 +1,50 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {void} Do not return anything, modify head in-place instead.
+ */
+var reorderList = function(head) {
+    if (!head) { return };
+    
+    let slow = head;
+    let fast = head;
+    
+    
+    // finding the middle of the linked list using 2 pters
+    while (fast && fast.next) {
+        slow = slow.next;
+        fast = fast.next.next;
+    }
+    
+    // reverse the second part of the list starting at slow
+    let prev = null
+    let curr = slow; 
+    while (curr) {
+        let next = curr.next;
+        curr.next = prev;
+        prev = curr;
+        curr = next;
+    } // here prev is the head 
+    
+    // merge two sorted lists (first one starts at head, second at prev)
+    let first = head;
+    let second = prev;
+    
+    while(second.next) {
+        temp = first.next;
+        first.next = second;
+        first = temp;
+        
+        temp = second.next;
+        second.next = first;
+        second = temp;
+    }
+    
+    
+};

javascript/15-3Sum.js

@@ -0,0 +1,35 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function(nums) {
+    let res = [];
+    let left = 0;
+    let right = nums.length - 1;
+    nums.sort((a,b) => { return a - b })
+    
+    for (let i = 0; i < nums.length - 1; i++) {
+        if (nums[i] > 0) return res;
+        if (nums[i] === nums[i - 1]) continue;
+        
+        left = i + 1;
+        right = nums.length - 1;
+        let temp = 0;
+        
+        while (left < right) {
+            temp = nums[left] + nums[right] + nums[i];
+            if (temp === 0) {
+                res.push([nums[i], nums[left], nums[right]]);
+                left++;
+                right--;
+            
+            while(nums[left] == nums[left - 1]) { left++ };
+            
+            while (nums[right] == nums[right - 1]) { right-- };
+            
+            } else if (temp > 0) { right-- }
+            else if (temp < 0) { left++ }
+        }
+    }
+    return res;
+};

javascript/152-Maximum-Product-Subarray.js

@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxProduct = function(nums) {
+    let result = nums[0];
+    let prevMax = nums[0];
+    let prevMin = nums[0];
+    for(let i = 1; i < nums.length; i++) {
+        currMax = Math.max(nums[i], prevMax * nums[i], prevMin * nums[i]);
+        currMin = Math.min(nums[i], prevMax * nums[i], prevMin * nums[i]);
+        
+        prevMax = currMax;
+        prevMin = currMin;
+        
+        result = Math.max(currMax, result);
+    }
+    return result;
+
+};