Added tasks 100-918

Author: javadev

README.md

@@ -41,6 +41,19 @@ A **valid BST** is defined as follows:
 ```typescript
 import { TreeNode } from '../../com_github_leetcode/treenode'
 
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
 function dfs(node: TreeNode | null, lowerBound: number, upperBound: number): boolean {
     if (!node) return true
     if (node.val <= lowerBound) return false

src/main/ts/g0001_0100/s0098_validate_binary_search_tree/readme.md

@@ -0,0 +1,69 @@
+[![](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)
+
+## 100\. Same Tree
+
+Easy
+
+Given the roots of two binary trees `p` and `q`, write a function to check if they are the same or not.
+
+Two binary trees are considered the same if they are structurally identical, and the nodes have the same value.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/12/20/ex1.jpg)
+
+**Input:** p = [1,2,3], q = [1,2,3]
+
+**Output:** true 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/12/20/ex2.jpg)
+
+**Input:** p = [1,2], q = [1,null,2]
+
+**Output:** false 
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2020/12/20/ex3.jpg)
+
+**Input:** p = [1,2,1], q = [1,1,2]
+
+**Output:** false 
+
+**Constraints:**
+
+*   The number of nodes in both trees is in the range `[0, 100]`.
+*   <code>-10<sup>4</sup> <= Node.val <= 10<sup>4</sup></code>
+
+## Solution
+
+```typescript
+import { TreeNode } from '../../com_github_leetcode/treenode'
+
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+function isSameTree(p: TreeNode | null, q: TreeNode | null): boolean {
+    if (p === null || q === null) {
+        return p === null && q === null
+    }
+    const b1 = isSameTree(p.left, q.left)
+    const b2 = isSameTree(p.right, q.right)
+    return p.val === q.val && b1 && b2
+}
+
+export { isSameTree }
+```

src/main/ts/g0001_0100/s0100_same_tree/readme.md

@@ -0,0 +1,57 @@
+[![](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)
+
+## 274\. H-Index
+
+Medium
+
+Given an array of integers `citations` where `citations[i]` is the number of citations a researcher received for their <code>i<sup>th</sup></code> paper, return compute the researcher's `h`**\-index**.
+
+According to the [definition of h-index on Wikipedia](https://en.wikipedia.org/wiki/H-index): A scientist has an index `h` if `h` of their `n` papers have at least `h` citations each, and the other `n − h` papers have no more than `h` citations each.
+
+If there are several possible values for `h`, the maximum one is taken as the `h`**\-index**.
+
+**Example 1:**
+
+**Input:** citations = [3,0,6,1,5]
+
+**Output:** 3
+
+**Explanation:**
+
+    [3,0,6,1,5] means the researcher has 5 papers in total and each of them had received 3, 0, 6, 1, 5 citations respectively.
+    Since the researcher has 3 papers with at least 3 citations each and the remaining two with no more than 3 citations each, their h-index is 3. 
+
+**Example 2:**
+
+**Input:** citations = [1,3,1]
+
+**Output:** 1 
+
+**Constraints:**
+
+*   `n == citations.length`
+*   `1 <= n <= 5000`
+*   `0 <= citations[i] <= 1000`
+
+## Solution
+
+```typescript
+function hIndex(citations: number[]): number {
+    const len = citations.length
+    const freqArray = new Array(len + 1).fill(0)
+    for (const citation of citations) {
+        freqArray[Math.min(citation, len)]++
+    }
+    let totalSoFar = 0
+    for (let k = len; k >= 0; k--) {
+        totalSoFar += freqArray[k]
+        if (totalSoFar >= k) {
+            return k
+        }
+    }
+    return -1
+}
+
+export { hIndex }
+```

src/main/ts/g0201_0300/s0274_h_index/readme.md

@@ -0,0 +1,94 @@
+[![](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)
+
+## 380\. Insert Delete GetRandom O(1)
+
+Medium
+
+Implement the `RandomizedSet` class:
+
+*   `RandomizedSet()` Initializes the `RandomizedSet` object.
+*   `bool insert(int val)` Inserts an item `val` into the set if not present. Returns `true` if the item was not present, `false` otherwise.
+*   `bool remove(int val)` Removes an item `val` from the set if present. Returns `true` if the item was present, `false` otherwise.
+*   `int getRandom()` Returns a random element from the current set of elements (it's guaranteed that at least one element exists when this method is called). Each element must have the **same probability** of being returned.
+
+You must implement the functions of the class such that each function works in **average** `O(1)` time complexity.
+
+**Example 1:**
+
+**Input** 
+
+    ["RandomizedSet", "insert", "remove", "insert", "getRandom", "remove", "insert", "getRandom"] 
+    [[], [1], [2], [2], [], [1], [2], []]
+
+**Output:** [null, true, false, true, 2, true, false, 2]
+
+**Explanation:** 
+
+    RandomizedSet randomizedSet = new RandomizedSet(); 
+    randomizedSet.insert(1); // Inserts 1 to the set. Returns true as 1 was inserted successfully. 
+    randomizedSet.remove(2); // Returns false as 2 does not exist in the set. 
+    randomizedSet.insert(2); // Inserts 2 to the set, returns true. Set now contains [1,2]. 
+    randomizedSet.getRandom(); // getRandom() should return either 1 or 2 randomly. 
+    randomizedSet.remove(1); // Removes 1 from the set, returns true. Set now contains [2]. 
+    randomizedSet.insert(2); // 2 was already in the set, so return false. 
+    randomizedSet.getRandom(); // Since 2 is the only number in the set, getRandom() will always return 2.
+
+**Constraints:**
+
+*   <code>-2<sup>31</sup> <= val <= 2<sup>31</sup> - 1</code>
+*   At most `2 * `<code>10<sup>5</sup></code> calls will be made to `insert`, `remove`, and `getRandom`.
+*   There will be **at least one** element in the data structure when `getRandom` is called.
+
+## Solution
+
+```typescript
+class RandomizedSet {
+    private rand: () => number
+    private list: number[]
+    private map: Map<number, number>
+
+    constructor() {
+        this.rand = () => Math.floor(Math.random() * this.list.length) // NOSONAR
+        this.list = []
+        this.map = new Map()
+    }
+
+    insert(val: number): boolean {
+        if (this.map.has(val)) {
+            return false
+        }
+        this.map.set(val, this.list.length)
+        this.list.push(val)
+        return true
+    }
+
+    remove(val: number): boolean {
+        if (!this.map.has(val)) {
+            return false
+        }
+        const swap1 = this.map.get(val)!
+        const swap2 = this.list.length - 1
+        const val2 = this.list[swap2]
+        this.map.set(val2, swap1)
+        this.map.delete(val)
+        this.list[swap1] = val2
+        this.list.pop()
+        return true
+    }
+
+    getRandom(): number {
+        return this.list[this.rand()]
+    }
+}
+
+/**
+ * Your RandomizedSet object will be instantiated and called as such:
+ * var obj = new RandomizedSet()
+ * var param_1 = obj.insert(val)
+ * var param_2 = obj.remove(val)
+ * var param_3 = obj.getRandom()
+ */
+
+export { RandomizedSet }
+```

src/main/ts/g0301_0400/s0380_insert_delete_getrandom_o1/readme.md

@@ -0,0 +1,116 @@
+[![](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)
+
+## 399\. Evaluate Division
+
+Medium
+
+You are given an array of variable pairs `equations` and an array of real numbers `values`, where <code>equations[i] = [A<sub>i</sub>, B<sub>i</sub>]</code> and `values[i]` represent the equation <code>A<sub>i</sub> / B<sub>i</sub> = values[i]</code>. Each <code>A<sub>i</sub></code> or <code>B<sub>i</sub></code> is a string that represents a single variable.
+
+You are also given some `queries`, where <code>queries[j] = [C<sub>j</sub>, D<sub>j</sub>]</code> represents the <code>j<sup>th</sup></code> query where you must find the answer for <code>C<sub>j</sub> / D<sub>j</sub> = ?</code>.
+
+Return _the answers to all queries_. If a single answer cannot be determined, return `-1.0`.
+
+**Note:** The input is always valid. You may assume that evaluating the queries will not result in division by zero and that there is no contradiction.
+
+**Example 1:**
+
+**Input:** equations = \[\["a","b"],["b","c"]], values = [2.0,3.0], queries = \[\["a","c"],["b","a"],["a","e"],["a","a"],["x","x"]]
+
+**Output:** [6.00000,0.50000,-1.00000,1.00000,-1.00000]
+
+**Explanation:**
+
+Given: _a / b = 2.0_, _b / c = 3.0_
+
+queries are: _a / c = ?_, _b / a = ?_, _a / e = ?_, _a / a = ?_, _x / x = ?_
+
+return: [6.0, 0.5, -1.0, 1.0, -1.0 ]
+
+**Example 2:**
+
+**Input:** equations = \[\["a","b"],["b","c"],["bc","cd"]], values = [1.5,2.5,5.0], queries = \[\["a","c"],["c","b"],["bc","cd"],["cd","bc"]]
+
+**Output:** [3.75000,0.40000,5.00000,0.20000]
+
+**Example 3:**
+
+**Input:** equations = \[\["a","b"]], values = [0.5], queries = \[\["a","b"],["b","a"],["a","c"],["x","y"]]
+
+**Output:** [0.50000,2.00000,-1.00000,-1.00000]
+
+**Constraints:**
+
+*   `1 <= equations.length <= 20`
+*   `equations[i].length == 2`
+*   <code>1 <= A<sub>i</sub>.length, B<sub>i</sub>.length <= 5</code>
+*   `values.length == equations.length`
+*   `0.0 < values[i] <= 20.0`
+*   `1 <= queries.length <= 20`
+*   `queries[i].length == 2`
+*   <code>1 <= C<sub>j</sub>.length, D<sub>j</sub>.length <= 5</code>
+*   <code>A<sub>i</sub>, B<sub>i</sub>, C<sub>j</sub>, D<sub>j</sub></code> consist of lower case English letters and digits.
+
+## Solution
+
+```typescript
+type MapType = Map<string, string>
+type RateType = Map<string, number>
+
+function calcEquation(equations: [string, string][], values: number[], queries: [string, string][]): number[] {
+    const root: MapType = new Map()
+    const rate: RateType = new Map()
+    for (const [x, y] of equations) {
+        if (!root.has(x)) {
+            root.set(x, x)
+            rate.set(x, 1.0)
+        }
+        if (!root.has(y)) {
+            root.set(y, y)
+            rate.set(y, 1.0)
+        }
+    }
+    for (let i = 0; i < equations.length; ++i) {
+        const [x, y] = equations[i]
+        union(x, y, values[i], root, rate)
+    }
+    const result: number[] = []
+    for (const [x, y] of queries) {
+        if (!root.has(x) || !root.has(y)) {
+            result.push(-1.0)
+        } else {
+            const rootX = findRoot(x, x, 1.0, root, rate)
+            const rootY = findRoot(y, y, 1.0, root, rate)
+            if (rootX === rootY) {
+                result.push(rate.get(x)! / rate.get(y)!)
+            } else {
+                result.push(-1.0)
+            }
+        }
+    }
+    return result
+}
+
+function union(x: string, y: string, value: number, root: MapType, rate: RateType): void {
+    const rootX = findRoot(x, x, 1.0, root, rate)
+    const rootY = findRoot(y, y, 1.0, root, rate)
+
+    if (rootX !== rootY) {
+        root.set(rootX, rootY)
+        const rateX = rate.get(x)!
+        const rateY = rate.get(y)!
+        rate.set(rootX, (value * rateY) / rateX)
+    }
+}
+
+function findRoot(originalX: string, x: string, rateSoFar: number, root: MapType, rate: RateType): string {
+    if (root.get(x) === x) {
+        root.set(originalX, x)
+        rate.set(originalX, rateSoFar * rate.get(x)!)
+        return x
+    }
+    return findRoot(originalX, root.get(x)!, rateSoFar * rate.get(x)!, root, rate)
+}
+
+export { calcEquation }
+```