Added tasks 57-137

Author: javadev

Diff for: README.md

@@ -0,0 +1,83 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-TypeScript/LeetCode-in-TypeScript?label=Stars&style=flat-square)](https://github.com/LeetCode-in-TypeScript/LeetCode-in-TypeScript)
+[![](https://img.shields.io/github/forks/LeetCode-in-TypeScript/LeetCode-in-TypeScript?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-TypeScript/LeetCode-in-TypeScript/fork)
+
+## 57\. Insert Interval
+
+Medium
+
+You are given an array of non-overlapping intervals `intervals` where <code>intervals[i] = [start<sub>i</sub>, end<sub>i</sub>]</code> represent the start and the end of the <code>i<sup>th</sup></code> interval and `intervals` is sorted in ascending order by <code>start<sub>i</sub></code>. You are also given an interval `newInterval = [start, end]` that represents the start and end of another interval.
+
+Insert `newInterval` into `intervals` such that `intervals` is still sorted in ascending order by <code>start<sub>i</sub></code> and `intervals` still does not have any overlapping intervals (merge overlapping intervals if necessary).
+
+Return `intervals` _after the insertion_.
+
+**Example 1:**
+
+**Input:** intervals = \[\[1,3],[6,9]], newInterval = [2,5]
+
+**Output:** [[1,5],[6,9]] 
+
+**Example 2:**
+
+**Input:** intervals = \[\[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
+
+**Output:** [[1,2],[3,10],[12,16]]
+
+**Explanation:** Because the new interval `[4,8]` overlaps with `[3,5],[6,7],[8,10]`.
+
+**Example 3:**
+
+**Input:** intervals = [], newInterval = [5,7]
+
+**Output:** [[5,7]] 
+
+**Example 4:**
+
+**Input:** intervals = \[\[1,5]], newInterval = [2,3]
+
+**Output:** [[1,5]] 
+
+**Example 5:**
+
+**Input:** intervals = \[\[1,5]], newInterval = [2,7]
+
+**Output:** [[1,7]] 
+
+**Constraints:**
+
+*   <code>0 <= intervals.length <= 10<sup>4</sup></code>
+*   `intervals[i].length == 2`
+*   <code>0 <= start<sub>i</sub> <= end<sub>i</sub> <= 10<sup>5</sup></code>
+*   `intervals` is sorted by <code>start<sub>i</sub></code> in **ascending** order.
+*   `newInterval.length == 2`
+*   <code>0 <= start <= end <= 10<sup>5</sup></code>
+
+## Solution
+
+```typescript
+function insert(intervals: number[][], newInterval: number[]): number[][] {
+    const n = intervals.length
+    let l = 0
+    let r = n - 1
+    while (l < n && newInterval[0] > intervals[l][1]) {
+        l++
+    }
+    while (r >= 0 && newInterval[1] < intervals[r][0]) {
+        r--
+    }
+    const res: number[][] = new Array(l + n - r).fill(0).map(() => new Array(2))
+    for (let i = 0; i < l; i++) {
+        res[i] = [...intervals[i]]
+    }
+    res[l] = [
+        Math.min(newInterval[0], l === n ? newInterval[0] : intervals[l][0]),
+        Math.max(newInterval[1], r === -1 ? newInterval[1] : intervals[r][1]),
+    ]
+    for (let i = l + 1, j = r + 1; j < n; i++, j++) {
+        res[i] = intervals[j]
+    }
+    return res
+}
+
+export { insert }
+```

Diff for: src/main/ts/g0001_0100/s0057_insert_interval/readme.md

@@ -0,0 +1,59 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-TypeScript/LeetCode-in-TypeScript?label=Stars&style=flat-square)](https://github.com/LeetCode-in-TypeScript/LeetCode-in-TypeScript)
+[![](https://img.shields.io/github/forks/LeetCode-in-TypeScript/LeetCode-in-TypeScript?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-TypeScript/LeetCode-in-TypeScript/fork)
+
+## 58\. Length of Last Word
+
+Easy
+
+Given a string `s` consisting of some words separated by some number of spaces, return _the length of the **last** word in the string._
+
+A **word** is a maximal substring consisting of non-space characters only.
+
+**Example 1:**
+
+**Input:** s = "Hello World"
+
+**Output:** 5
+
+**Explanation:** The last word is "World" with length 5. 
+
+**Example 2:**
+
+**Input:** s = " fly me to the moon "
+
+**Output:** 4
+
+**Explanation:** The last word is "moon" with length 4. 
+
+**Example 3:**
+
+**Input:** s = "luffy is still joyboy"
+
+**Output:** 6
+
+**Explanation:** The last word is "joyboy" with length 6. 
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>4</sup></code>
+*   `s` consists of only English letters and spaces `' '`.
+*   There will be at least one word in `s`.
+
+## Solution
+
+```typescript
+function lengthOfLastWord(s: string): number {
+    let len = 0
+    for (let i = s.length - 1; i >= 0; i--) {
+        const ch = s[i]
+        if (ch === ' ' && len > 0) {
+            break
+        } else if (ch !== ' ') {
+            len++
+        }
+    }
+    return len
+}
+
+export { lengthOfLastWord }
+```

Diff for: src/main/ts/g0001_0100/s0058_length_of_last_word/readme.md

@@ -0,0 +1,71 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-TypeScript/LeetCode-in-TypeScript?label=Stars&style=flat-square)](https://github.com/LeetCode-in-TypeScript/LeetCode-in-TypeScript)
+[![](https://img.shields.io/github/forks/LeetCode-in-TypeScript/LeetCode-in-TypeScript?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-TypeScript/LeetCode-in-TypeScript/fork)
+
+## 61\. Rotate List
+
+Medium
+
+Given the `head` of a linked list, rotate the list to the right by `k` places.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/13/rotate1.jpg)
+
+**Input:** head = [1,2,3,4,5], k = 2
+
+**Output:** [4,5,1,2,3] 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/13/roate2.jpg)
+
+**Input:** head = [0,1,2], k = 4
+
+**Output:** [2,0,1] 
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range `[0, 500]`.
+*   `-100 <= Node.val <= 100`
+*   <code>0 <= k <= 2 * 10<sup>9</sup></code>
+
+## Solution
+
+```typescript
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+function rotateRight(head: ListNode | null, k: number): ListNode | null {
+    if (!head || k === 0) {
+        return head
+    }
+    let tail: ListNode | null = head
+    let count = 1
+    while (tail.next) {
+        count++
+        tail = tail.next
+    }
+    let times = k % count
+    if (times === 0) {
+        return head
+    }
+    let temp: ListNode | null = head
+    for (let i = 1; i < count - times; i++) {
+        temp = temp!.next
+    }
+    let newHead = temp!.next
+    temp!.next = null
+    tail!.next = head
+    return newHead
+}
+
+export { rotateRight }
+```

Diff for: src/main/ts/g0001_0100/s0061_rotate_list/readme.md

@@ -0,0 +1,78 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-TypeScript/LeetCode-in-TypeScript?label=Stars&style=flat-square)](https://github.com/LeetCode-in-TypeScript/LeetCode-in-TypeScript)
+[![](https://img.shields.io/github/forks/LeetCode-in-TypeScript/LeetCode-in-TypeScript?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-TypeScript/LeetCode-in-TypeScript/fork)
+
+## 63\. Unique Paths II
+
+Medium
+
+A robot is located at the top-left corner of a `m x n` grid (marked 'Start' in the diagram below).
+
+The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).
+
+Now consider if some obstacles are added to the grids. How many unique paths would there be?
+
+An obstacle and space is marked as `1` and `0` respectively in the grid.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/04/robot1.jpg)
+
+**Input:** obstacleGrid = \[\[0,0,0],[0,1,0],[0,0,0]]
+
+**Output:** 2
+
+**Explanation:** There is one obstacle in the middle of the 3x3 grid above. There are two ways to reach the bottom-right corner: 1. Right -> Right -> Down -> Down 2. Down -> Down -> Right -> Right 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/04/robot2.jpg)
+
+**Input:** obstacleGrid = \[\[0,1],[0,0]]
+
+**Output:** 1 
+
+**Constraints:**
+
+*   `m == obstacleGrid.length`
+*   `n == obstacleGrid[i].length`
+*   `1 <= m, n <= 100`
+*   `obstacleGrid[i][j]` is `0` or `1`.
+
+## Solution
+
+```typescript
+function uniquePathsWithObstacles(obstacleGrid: number[][]): number {
+    if (obstacleGrid[0][0] === 1) {
+        return 0
+    }
+    obstacleGrid[0][0] = 1
+    const m = obstacleGrid.length
+    const n = obstacleGrid[0].length
+    for (let i = 1; i < m; i++) {
+        if (obstacleGrid[i][0] === 1) {
+            obstacleGrid[i][0] = 0
+        } else {
+            obstacleGrid[i][0] = obstacleGrid[i - 1][0]
+        }
+    }
+    for (let j = 1; j < n; j++) {
+        if (obstacleGrid[0][j] === 1) {
+            obstacleGrid[0][j] = 0
+        } else {
+            obstacleGrid[0][j] = obstacleGrid[0][j - 1]
+        }
+    }
+    for (let i = 1; i < m; i++) {
+        for (let j = 1; j < n; j++) {
+            if (obstacleGrid[i][j] === 1) {
+                obstacleGrid[i][j] = 0
+            } else {
+                obstacleGrid[i][j] = obstacleGrid[i - 1][j] + obstacleGrid[i][j - 1]
+            }
+        }
+    }
+    return obstacleGrid[m - 1][n - 1]
+}
+
+export { uniquePathsWithObstacles }
+```

Diff for: src/main/ts/g0001_0100/s0063_unique_paths_ii/readme.md

@@ -0,0 +1,73 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-TypeScript/LeetCode-in-TypeScript?label=Stars&style=flat-square)](https://github.com/LeetCode-in-TypeScript/LeetCode-in-TypeScript)
+[![](https://img.shields.io/github/forks/LeetCode-in-TypeScript/LeetCode-in-TypeScript?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-TypeScript/LeetCode-in-TypeScript/fork)
+
+## 66\. Plus One
+
+Easy
+
+You are given a **large integer** represented as an integer array `digits`, where each `digits[i]` is the `ith` digit of the integer. The digits are ordered from most significant to least significant in left-to-right order. The large integer does not contain any leading `0`'s.
+
+Increment the large integer by one and return _the resulting array of digits_.
+
+**Example 1:**
+
+**Input:** digits = [1,2,3]
+
+**Output:** [1,2,4]
+
+**Explanation:** The array represents the integer 123. Incrementing by one gives 123 + 1 = 124. Thus, the result should be [1,2,4]. 
+
+**Example 2:**
+
+**Input:** digits = [4,3,2,1]
+
+**Output:** [4,3,2,2]
+
+**Explanation:** The array represents the integer 4321. Incrementing by one gives 4321 + 1 = 4322. Thus, the result should be [4,3,2,2]. 
+
+**Example 3:**
+
+**Input:** digits = [0]
+
+**Output:** [1]
+
+**Explanation:** The array represents the integer 0. Incrementing by one gives 0 + 1 = 1. Thus, the result should be [1]. 
+
+**Example 4:**
+
+**Input:** digits = [9]
+
+**Output:** [1,0]
+
+**Explanation:** The array represents the integer 9. Incrementing by one gives 9 + 1 = 10. Thus, the result should be [1,0]. 
+
+**Constraints:**
+
+*   `1 <= digits.length <= 100`
+*   `0 <= digits[i] <= 9`
+*   `digits` does not contain any leading `0`'s.
+
+## Solution
+
+```typescript
+function plusOne(digits: number[]): number[] {
+    let num = 1
+    let carry = 0
+    let sum
+    for (let i = digits.length - 1; i >= 0; i--) {
+        if (i === digits.length - 1) {
+            sum = digits[i] + carry + num
+        } else {
+            sum = digits[i] + carry
+        }
+        carry = Math.floor(sum / 10)
+        digits[i] = sum % 10
+    }
+    if (carry !== 0) {
+        return [carry, ...digits]
+    }
+    return digits
+}
+
+export { plusOne }
+```