Added javascript tasks

Author: javadev

src/main/js/g0001_0100/s0021_merge_two_sorted_lists/readme.md

@@ -36,7 +36,7 @@ Merge two sorted linked lists and return it as a **sorted** list. The list shoul
 ## Solution
 
 ```javascript
-import { ListNode } from "../../com_github_leetcode/listnode";
+import { ListNode } from '../../com_github_leetcode/listnode';
 
 /**
  * Definition for singly-linked list.

src/main/js/g0001_0100/s0056_merge_intervals/readme.md

@@ -0,0 +1,62 @@
+[![](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)
+
+## 56\. Merge Intervals
+
+Medium
+
+Given an array of `intervals` where <code>intervals[i] = [start<sub>i</sub>, end<sub>i</sub>]</code>, merge all overlapping intervals, and return _an array of the non-overlapping intervals that cover all the intervals in the input_.
+
+**Example 1:**
+
+**Input:** intervals = \[\[1,3],[2,6],[8,10],[15,18]]
+
+**Output:** [[1,6],[8,10],[15,18]]
+
+**Explanation:** Since intervals [1,3] and [2,6] overlap, merge them into [1,6].
+
+**Example 2:**
+
+**Input:** intervals = \[\[1,4],[4,5]]
+
+**Output:** [[1,5]]
+
+**Explanation:** Intervals [1,4] and [4,5] are considered overlapping.
+
+**Constraints:**
+
+*   <code>1 <= intervals.length <= 10<sup>4</sup></code>
+*   `intervals[i].length == 2`
+*   <code>0 <= start<sub>i</sub> <= end<sub>i</sub> <= 10<sup>4</sup></code>
+
+## Solution
+
+```javascript
+/**
+ * @param {number[][]} intervals
+ * @return {number[][]}
+ */
+var merge = function(intervals) {
+    // Sort intervals based on the starting points
+    intervals.sort((a, b) => a[0] - b[0])
+    
+    const result = []
+    let current = intervals[0]
+    result.push(current)
+    
+    for (const next of intervals) {
+        if (current[1] >= next[0]) {
+            // Merge intervals
+            current[1] = Math.max(current[1], next[1])
+        } else {
+            // Move to the next interval
+            current = next;
+            result.push(current)
+        }
+    }
+    
+    return result;
+};
+
+export { merge }
+```

src/main/js/g0001_0100/s0062_unique_paths/readme.md

@@ -0,0 +1,72 @@
+[![](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)
+
+## 62\. Unique Paths
+
+Medium
+
+There is a robot on an `m x n` grid. The robot is initially located at the **top-left corner** (i.e., `grid[0][0]`). The robot tries to move to the **bottom-right corner** (i.e., `grid[m - 1][n - 1]`). The robot can only move either down or right at any point in time.
+
+Given the two integers `m` and `n`, return _the number of possible unique paths that the robot can take to reach the bottom-right corner_.
+
+The test cases are generated so that the answer will be less than or equal to <code>2 * 10<sup>9</sup></code>.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2018/10/22/robot_maze.png)
+
+**Input:** m = 3, n = 7
+
+**Output:** 28
+
+**Example 2:**
+
+**Input:** m = 3, n = 2
+
+**Output:** 3
+
+**Explanation:** From the top-left corner, there are a total of 3 ways to reach the bottom-right corner: 
+
+1. Right -> Down -> Down 
+
+2. Down -> Down -> Right 
+
+3. Down -> Right -> Down
+
+**Constraints:**
+
+*   `1 <= m, n <= 100`
+
+## Solution
+
+```javascript
+/**
+ * @param {number} m
+ * @param {number} n
+ * @return {number}
+ */
+var uniquePaths = function(m, n) {
+    // Initialize a 2D array with all values set to 0
+    const dp = Array.from({ length: m }, () => Array(n).fill(0))
+    
+    // Fill the first row and first column with 1
+    for (let i = 0; i < m; i++) {
+        dp[i][0] = 1
+    }
+    for (let j = 0; j < n; j++) {
+        dp[0][j] = 1
+    }
+    
+    // Fill the rest of the dp table
+    for (let i = 1; i < m; i++) {
+        for (let j = 1; j < n; j++) {
+            dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
+        }
+    }
+    
+    // The answer is in the bottom-right corner
+    return dp[m - 1][n - 1]
+};
+
+export { uniquePaths }
+```

src/main/js/g0001_0100/s0064_minimum_path_sum/readme.md

@@ -0,0 +1,90 @@
+[![](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)
+
+## 64\. Minimum Path Sum
+
+Medium
+
+Given a `m x n` `grid` filled with non-negative numbers, find a path from top left to bottom right, which minimizes the sum of all numbers along its path.
+
+**Note:** You can only move either down or right at any point in time.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/05/minpath.jpg)
+
+**Input:** grid = \[\[1,3,1],[1,5,1],[4,2,1]]
+
+**Output:** 7
+
+**Explanation:** Because the path 1 → 3 → 1 → 1 → 1 minimizes the sum.
+
+**Example 2:**
+
+**Input:** grid = \[\[1,2,3],[4,5,6]]
+
+**Output:** 12
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `1 <= m, n <= 200`
+*   `0 <= grid[i][j] <= 100`
+
+## Solution
+
+```javascript
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var minPathSum = function(grid) {
+    const rows = grid.length
+    const cols = grid[0].length
+
+    // Handle the special case where grid has only one cell
+    if (rows === 1 && cols === 1) {
+        return grid[0][0]
+    }
+
+    // Create a 2D array for dynamic programming
+    const dm = Array.from({ length: rows }, () => Array(cols).fill(0))
+
+    // Initialize the last column
+    let s = 0
+    for (let r = rows - 1; r >= 0; r--) {
+        dm[r][cols - 1] = grid[r][cols - 1] + s
+        s += grid[r][cols - 1]
+    }
+
+    // Initialize the last row
+    s = 0
+    for (let c = cols - 1; c >= 0; c--) {
+        dm[rows - 1][c] = grid[rows - 1][c] + s
+        s += grid[rows - 1][c]
+    }
+
+    // Recursive helper function
+    const recur = (r, c) => {
+        if (
+            dm[r][c] === 0 &&
+            r !== rows - 1 &&
+            c !== cols - 1
+        ) {
+            dm[r][c] =
+                grid[r][c] +
+                Math.min(
+                    recur(r + 1, c),
+                    recur(r, c + 1)
+                )
+        }
+        return dm[r][c]
+    }
+
+    // Start recursion from the top-left corner
+    return recur(0, 0)
+};
+
+export { minPathSum }
+```

src/main/js/g0001_0100/s0070_climbing_stairs/readme.md

@@ -0,0 +1,71 @@
+[![](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)
+
+## 70\. Climbing Stairs
+
+Easy
+
+You are climbing a staircase. It takes `n` steps to reach the top.
+
+Each time you can either climb `1` or `2` steps. In how many distinct ways can you climb to the top?
+
+**Example 1:**
+
+**Input:** n = 2
+
+**Output:** 2
+
+**Explanation:** There are two ways to climb to the top. 
+
+1. 1 step + 1 step 
+
+2. 2 steps
+
+**Example 2:**
+
+**Input:** n = 3
+
+**Output:** 3
+
+**Explanation:** There are three ways to climb to the top. 
+
+1. 1 step + 1 step + 1 step 
+
+2. 1 step + 2 steps 
+
+3. 2 steps + 1 step
+
+**Constraints:**
+
+*   `1 <= n <= 45`
+
+## Solution
+
+```javascript
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var climbStairs = function(n) {
+    if (n < 2) {
+        return n
+    }
+
+    // Create a cache (DP array) to store results
+    const cache = new Array(n)
+
+    // Initialize base cases
+    cache[0] = 1
+    cache[1] = 2
+
+    // Fill the cache using the recurrence relation
+    for (let i = 2; i < n; i++) {
+        cache[i] = cache[i - 1] + cache[i - 2]
+    }
+
+    // Return the result for the nth step
+    return cache[n - 1]
+};
+
+export { climbStairs }
+```