Added tasks 149-209

Author: javadev

README.md

@@ -0,0 +1,64 @@
+[![](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)
+
+## 149\. Max Points on a Line
+
+Hard
+
+Given an array of `points` where <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> represents a point on the **X-Y** plane, return _the maximum number of points that lie on the same straight line_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/25/plane1.jpg)
+
+**Input:** points = \[\[1,1],[2,2],[3,3]]
+
+**Output:** 3 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/02/25/plane2.jpg)
+
+**Input:** points = \[\[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]
+
+**Output:** 4 
+
+**Constraints:**
+
+*   `1 <= points.length <= 300`
+*   `points[i].length == 2`
+*   <code>-10<sup>4</sup> <= x<sub>i</sub>, y<sub>i</sub> <= 10<sup>4</sup></code>
+*   All the `points` are **unique**.
+
+## Solution
+
+```typescript
+function maxPoints(points: number[][]): number {
+    if (points.length <= 2) {
+        return points.length
+    }
+    const map = new Map<number, number>()
+    let result: number = 0
+    for (let i = 0; i < points.length; i++) {
+        const [x0, y0] = points[i]
+        for (let j = i + 1; j < points.length; j++) {
+            const [x1, y1] = points[j]
+            let m: number
+            if (x0 === x1) {
+                m = Number.MAX_VALUE
+            } else if (y0 === y1) {
+                m = 0
+            } else {
+                m = (y0 - y1) / (x0 - x1)
+            }
+            const nextM: number = map.has(m) ? map.get(m) + 1 : 2
+            map.set(m, nextM)
+            result = Math.max(result, nextM)
+        }
+        map.clear()
+    }
+    return result
+}
+
+export { maxPoints }
+```

src/main/ts/g0101_0200/s0149_max_points_on_a_line/readme.md

@@ -0,0 +1,77 @@
+[![](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)
+
+## 150\. Evaluate Reverse Polish Notation
+
+Medium
+
+Evaluate the value of an arithmetic expression in [Reverse Polish Notation](http://en.wikipedia.org/wiki/Reverse_Polish_notation).
+
+Valid operators are `+`, `-`, `*`, and `/`. Each operand may be an integer or another expression.
+
+**Note** that division between two integers should truncate toward zero.
+
+It is guaranteed that the given RPN expression is always valid. That means the expression would always evaluate to a result, and there will not be any division by zero operation.
+
+**Example 1:**
+
+**Input:** tokens = ["2","1","+","3","\*"]
+
+**Output:** 9
+
+**Explanation:** ((2 + 1) \* 3) = 9 
+
+**Example 2:**
+
+**Input:** tokens = ["4","13","5","/","+"]
+
+**Output:** 6
+
+**Explanation:** (4 + (13 / 5)) = 6 
+
+**Example 3:**
+
+**Input:** tokens = ["10","6","9","3","+","-11","\*","/","\*","17","+","5","+"]
+
+**Output:** 22
+
+**Explanation:**
+
+    ((10 \* (6 / ((9 + 3) \* -11))) + 17) + 5
+    = ((10 \* (6 / (12 \* -11))) + 17) + 5
+    = ((10 \* (6 / -132)) + 17) + 5
+    = ((10 \* 0) + 17) + 5
+    = (0 + 17) + 5
+    = 17 + 5
+    = 22 
+
+**Constraints:**
+
+*   <code>1 <= tokens.length <= 10<sup>4</sup></code>
+*   `tokens[i]` is either an operator: `"+"`, `"-"`, `"*"`, or `"/"`, or an integer in the range `[-200, 200]`.
+
+## Solution
+
+```typescript
+function evalRPN(tokens: string[]): number {
+    const numberStack: number[] = []
+    const isOperator = (val: string): boolean => val === '+' || val === '-' || val === '*' || val === '/'
+    for (let token of tokens) {
+        if (isOperator(token)) {
+            const right = numberStack.pop() as number
+            const left = numberStack.pop() as number
+
+            if (token === '+') numberStack.push(left + right)
+            else if (token === '-') numberStack.push(left - right)
+            else if (token === '*') numberStack.push(left * right)
+            else if (token === '/') {
+                const result = left / right
+                numberStack.push(result < 0 ? Math.ceil(result) : Math.floor(result))
+            }
+        } else numberStack.push(+token)
+    }
+    return numberStack.pop() || 0
+}
+
+export { evalRPN }
+```

src/main/ts/g0101_0200/s0150_evaluate_reverse_polish_notation/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)
+
+## 151\. Reverse Words in a String
+
+Medium
+
+Given an input string `s`, reverse the order of the **words**.
+
+A **word** is defined as a sequence of non-space characters. The **words** in `s` will be separated by at least one space.
+
+Return _a string of the words in reverse order concatenated by a single space._
+
+**Note** that `s` may contain leading or trailing spaces or multiple spaces between two words. The returned string should only have a single space separating the words. Do not include any extra spaces.
+
+**Example 1:**
+
+**Input:** s = "the sky is blue"
+
+**Output:** "blue is sky the" 
+
+**Example 2:**
+
+**Input:** s = " hello world "
+
+**Output:** "world hello"
+
+**Explanation:** Your reversed string should not contain leading or trailing spaces. 
+
+**Example 3:**
+
+**Input:** s = "a good example"
+
+**Output:** "example good a"
+
+**Explanation:** You need to reduce multiple spaces between two words to a single space in the reversed string. 
+
+**Example 4:**
+
+**Input:** s = " Bob Loves Alice "
+
+**Output:** "Alice Loves Bob" 
+
+**Example 5:**
+
+**Input:** s = "Alice does not even like bob"
+
+**Output:** "bob like even not does Alice" 
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>4</sup></code>
+*   `s` contains English letters (upper-case and lower-case), digits, and spaces `' '`.
+*   There is **at least one** word in `s`.
+
+**Follow-up:** If the string data type is mutable in your language, can you solve it **in-place** with `O(1)` extra space?
+
+## Solution
+
+```typescript
+function reverseWords(s: string): string {
+    return s
+        ?.trim()
+        ?.replaceAll(/\s{2,}/g, ' ')
+        ?.split(' ')
+        ?.reverse()
+        .join(' ')
+}
+
+export { reverseWords }
+```

src/main/ts/g0101_0200/s0151_reverse_words_in_a_string/readme.md

@@ -0,0 +1,56 @@
+[![](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)
+
+## 162\. Find Peak Element
+
+Medium
+
+A peak element is an element that is strictly greater than its neighbors.
+
+Given an integer array `nums`, find a peak element, and return its index. If the array contains multiple peaks, return the index to **any of the peaks**.
+
+You may imagine that `nums[-1] = nums[n] = -∞`.
+
+You must write an algorithm that runs in `O(log n)` time.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,1]
+
+**Output:** 2
+
+**Explanation:** 3 is a peak element and your function should return the index number 2.
+
+**Example 2:**
+
+**Input:** nums = [1,2,1,3,5,6,4]
+
+**Output:** 5
+
+**Explanation:** Your function can return either index number 1 where the peak element is 2, or index number 5 where the peak element is 6.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   <code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code>
+*   `nums[i] != nums[i + 1]` for all valid `i`.
+
+## Solution
+
+```typescript
+function findPeakElement(nums: number[]): number {
+    let start = 0
+    let end = nums.length - 1
+    while (start < end) {
+        const mid = start + Math.floor((end - start) / 2)
+        if (nums[mid + 1] > nums[mid]) {
+            start = mid + 1
+        } else {
+            end = mid
+        }
+    }
+    return start
+}
+
+export { findPeakElement }
+```

src/main/ts/g0101_0200/s0162_find_peak_element/readme.md

@@ -0,0 +1,66 @@
+[![](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)
+
+## 167\. Two Sum II - Input Array Is Sorted
+
+Easy
+
+Given a **1-indexed** array of integers `numbers` that is already **_sorted in non-decreasing order_**, find two numbers such that they add up to a specific `target` number. Let these two numbers be <code>numbers[index<sub>1</sub>]</code> and <code>numbers[index<sub>2</sub>]</code> where <code>1 <= index<sub>1</sub> < index<sub>2</sub> <= numbers.length</code>.
+
+Return _the indices of the two numbers,_ <code>index<sub>1</sub></code> _and_ <code>index<sub>2</sub></code>_, **added by one** as an integer array_ <code>[index<sub>1</sub>, index<sub>2</sub>]</code> _of length 2._
+
+The tests are generated such that there is **exactly one solution**. You **may not** use the same element twice.
+
+**Example 1:**
+
+**Input:** numbers = [2,7,11,15], target = 9
+
+**Output:** [1,2]
+
+**Explanation:** The sum of 2 and 7 is 9. Therefore, index<sub>1</sub> = 1, index<sub>2</sub> = 2. We return [1, 2]. 
+
+**Example 2:**
+
+**Input:** numbers = [2,3,4], target = 6
+
+**Output:** [1,3]
+
+**Explanation:** The sum of 2 and 4 is 6. Therefore index<sub>1</sub> = 1, index<sub>2</sub> = 3. We return [1, 3]. 
+
+**Example 3:**
+
+**Input:** numbers = [\-1,0], target = -1
+
+**Output:** [1,2]
+
+**Explanation:** The sum of -1 and 0 is -1. Therefore index<sub>1</sub> = 1, index<sub>2</sub> = 2. We return [1, 2]. 
+
+**Constraints:**
+
+*   <code>2 <= numbers.length <= 3 * 10<sup>4</sup></code>
+*   `-1000 <= numbers[i] <= 1000`
+*   `numbers` is sorted in **non-decreasing order**.
+*   `-1000 <= target <= 1000`
+*   The tests are generated such that there is **exactly one solution**.
+
+## Solution
+
+```typescript
+function twoSum(numbers: number[], target: number): number[] {
+    let i = 0
+    let j = numbers.length - 1
+    while (i < j) {
+        const sum = numbers[i] + numbers[j]
+        if (sum === target) {
+            return [i + 1, j + 1]
+        } else if (sum < target) {
+            i++
+        } else {
+            j--
+        }
+    }
+    return []
+}
+
+export { twoSum }
+```

src/main/ts/g0101_0200/s0167_two_sum_ii_input_array_is_sorted/readme.md

@@ -0,0 +1,54 @@
+[![](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)
+
+## 172\. Factorial Trailing Zeroes
+
+Medium
+
+Given an integer `n`, return _the number of trailing zeroes in_ `n!`.
+
+Note that `n! = n * (n - 1) * (n - 2) * ... * 3 * 2 * 1`.
+
+**Example 1:**
+
+**Input:** n = 3
+
+**Output:** 0
+
+**Explanation:** 3! = 6, no trailing zero. 
+
+**Example 2:**
+
+**Input:** n = 5
+
+**Output:** 1
+
+**Explanation:** 5! = 120, one trailing zero. 
+
+**Example 3:**
+
+**Input:** n = 0
+
+**Output:** 0 
+
+**Constraints:**
+
+*   <code>0 <= n <= 10<sup>4</sup></code>
+
+**Follow up:** Could you write a solution that works in logarithmic time complexity?
+
+## Solution
+
+```typescript
+function trailingZeroes(n: number): number {
+    let base = 5
+    let count = 0
+    while (n >= base) {
+        count += Math.floor(n / base)
+        base *= 5
+    }
+    return count
+}
+
+export { trailingZeroes }
+```