Added js tasks

Author: javadev

src/main/js/g0101_0200/s0121_best_time_to_buy_and_sell_stock/readme.md

@@ -0,0 +1,60 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 121\. Best Time to Buy and Sell Stock
+
+Easy
+
+You are given an array `prices` where `prices[i]` is the price of a given stock on the <code>i<sup>th</sup></code> day.
+
+You want to maximize your profit by choosing a **single day** to buy one stock and choosing a **different day in the future** to sell that stock.
+
+Return _the maximum profit you can achieve from this transaction_. If you cannot achieve any profit, return `0`.
+
+**Example 1:**
+
+**Input:** prices = [7,1,5,3,6,4]
+
+**Output:** 5
+
+**Explanation:** Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5. 
+
+Note that buying on day 2 and selling on day 1 is not allowed because you must buy before you sell.
+
+**Example 2:**
+
+**Input:** prices = [7,6,4,3,1]
+
+**Output:** 0
+
+**Explanation:** In this case, no transactions are done and the max profit = 0.
+
+**Constraints:**
+
+*   <code>1 <= prices.length <= 10<sup>5</sup></code>
+*   <code>0 <= prices[i] <= 10<sup>4</sup></code>
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function(prices) {
+    let maxProfit = 0
+    let min = prices[0]
+    
+    for (let i = 1; i < prices.length; i++) {
+        if (prices[i] > min) {
+            maxProfit = Math.max(maxProfit, prices[i] - min)
+        } else {
+            min = prices[i]
+        }
+    }
+    
+    return maxProfit
+};
+
+export { maxProfit }
+```

src/main/js/g0101_0200/s0124_binary_tree_maximum_path_sum/readme.md

@@ -0,0 +1,81 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 124\. Binary Tree Maximum Path Sum
+
+Hard
+
+A **path** in a binary tree is a sequence of nodes where each pair of adjacent nodes in the sequence has an edge connecting them. A node can only appear in the sequence **at most once**. Note that the path does not need to pass through the root.
+
+The **path sum** of a path is the sum of the node's values in the path.
+
+Given the `root` of a binary tree, return _the maximum **path sum** of any **non-empty** path_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/10/13/exx1.jpg)
+
+**Input:** root = [1,2,3]
+
+**Output:** 6
+
+**Explanation:** The optimal path is 2 -> 1 -> 3 with a path sum of 2 + 1 + 3 = 6.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/10/13/exx2.jpg)
+
+**Input:** root = [-10,9,20,null,null,15,7]
+
+**Output:** 42
+
+**Explanation:** The optimal path is 15 -> 20 -> 7 with a path sum of 15 + 20 + 7 = 42.
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[1, 3 * 10<sup>4</sup>]</code>.
+*   `-1000 <= Node.val <= 1000`
+
+## Solution
+
+```javascript
+/**
+ * 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 maxPathSum = function(root) {
+    let max = Number.MIN_SAFE_INTEGER
+
+    const helper = (node) => {
+        if (node === null) {
+            return 0
+        }
+        
+        // Calculate max sum on the left and right subtrees, avoiding negatives
+        const left = Math.max(0, helper(node.left))
+        const right = Math.max(0, helper(node.right))
+        
+        // Current path sum including the node
+        const current = node.val + left + right
+        
+        // Update the global max if the current path sum is greater
+        max = Math.max(max, current)
+        
+        // Return the max sum of the path passing through the current node
+        return node.val + Math.max(left, right)
+    }
+
+    helper(root)
+    return max
+};
+
+export { maxPathSum }
+```

src/main/js/g0101_0200/s0128_longest_consecutive_sequence/readme.md

@@ -0,0 +1,60 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 128\. Longest Consecutive Sequence
+
+Medium
+
+Given an unsorted array of integers `nums`, return _the length of the longest consecutive elements sequence._
+
+You must write an algorithm that runs in `O(n)` time.
+
+**Example 1:**
+
+**Input:** nums = [100,4,200,1,3,2]
+
+**Output:** 4
+
+**Explanation:** The longest consecutive elements sequence is `[1, 2, 3, 4]`. Therefore its length is 4.
+
+**Example 2:**
+
+**Input:** nums = [0,3,7,2,5,8,4,6,0,1]
+
+**Output:** 9
+
+**Constraints:**
+
+*   <code>0 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var longestConsecutive = function(nums) {
+    if (nums.length === 0) {
+        return 0
+    }
+    nums.sort((a, b) => a - b)
+    let max = Number.MIN_SAFE_INTEGER
+    let thsMax = 1
+    for (let i = 0; i < nums.length - 1; i++) {
+        if (nums[i + 1] === nums[i] + 1) {
+            thsMax += 1
+            continue
+        }
+        if (nums[i + 1] === nums[i]) {
+            continue
+        }
+        max = Math.max(max, thsMax)
+        thsMax = 1 // NOSONAR
+    }
+    return Math.max(max, thsMax)
+};
+
+export { longestConsecutive }
+```

src/main/js/g0101_0200/s0131_palindrome_partitioning/readme.md

@@ -0,0 +1,67 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 131\. Palindrome Partitioning
+
+Medium
+
+Given a string `s`, partition `s` such that every substring of the partition is a **palindrome**. Return all possible palindrome partitioning of `s`.
+
+A **palindrome** string is a string that reads the same backward as forward.
+
+**Example 1:**
+
+**Input:** s = "aab"
+
+**Output:** [["a","a","b"],["aa","b"]]
+
+**Example 2:**
+
+**Input:** s = "a"
+
+**Output:** [["a"]]
+
+**Constraints:**
+
+*   `1 <= s.length <= 16`
+*   `s` contains only lowercase English letters.
+
+## Solution
+
+```javascript
+/**
+ * @param {string} s
+ * @return {string[][]}
+ */
+var partition = function(s) {
+    const res = []
+    backtracking(res, [], s, 0)
+    return res
+};
+
+const backtracking = (res, currArr, s, start) => {
+    if (start === s.length) {
+        res.push([...currArr]) // Add a copy of the current array to the result
+        return
+    }
+
+    for (let end = start; end < s.length; end++) {
+        if (!isPalindrome(s, start, end)) {
+            continue
+        }
+        currArr.push(s.substring(start, end + 1)) // Add the current substring
+        backtracking(res, currArr, s, end + 1) // Recurse to the next part
+        currArr.pop() // Remove the last element to backtrack
+    }
+};
+
+const isPalindrome = (s, start, end) => {
+    while (start < end && s[start] === s[end]) {
+        start++
+        end--
+    }
+    return start >= end
+};
+
+export { partition }
+```

src/main/js/g0101_0200/s0136_single_number/readme.md

@@ -0,0 +1,52 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 136\. Single Number
+
+Easy
+
+Given a **non-empty** array of integers `nums`, every element appears _twice_ except for one. Find that single one.
+
+You must implement a solution with a linear runtime complexity and use only constant extra space.
+
+**Example 1:**
+
+**Input:** nums = [2,2,1]
+
+**Output:** 1
+
+**Example 2:**
+
+**Input:** nums = [4,1,2,1,2]
+
+**Output:** 4
+
+**Example 3:**
+
+**Input:** nums = [1]
+
+**Output:** 1
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 3 * 10<sup>4</sup></code>
+*   <code>-3 * 10<sup>4</sup> <= nums[i] <= 3 * 10<sup>4</sup></code>
+*   Each element in the array appears twice except for one element which appears only once.
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var singleNumber = function(nums) {
+    let res = 0
+    for (const num of nums) {
+        res ^= num
+    }
+    return res
+};
+
+export { singleNumber }
+```