feat: add solutions to lc problems: No.1817,1826,1833,1835,1836 (doocs#1759)

* No.1817.Find the Users Active Minutes
* No.1826.Faulty Sensor
* No.1833.Maximum Ice Cream Bars
* No.1835.Find XOR Sum of All Pairs Bitwise AND
* No.1836.Remove Duplicates From an Unsorted Linked List

Author: yanglbme

solution/1800-1899/1817.Finding the Users Active Minutes/README.md

@@ -60,7 +60,7 @@ ID=2 的用户执行操作的分钟分别是：2 和 3 。因此，该用户的
 
 我们用哈希表 $d$ 记录每个用户的所有去重操作时间，然后遍历哈希表，统计每个用户的用户活跃分钟数，最后统计每个用户活跃分钟数的分布情况。
 
-时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 `logs` 的长度。
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $logs$ 的长度。
 
 <!-- tabs:start -->
 
@@ -141,6 +141,25 @@ func findingUsersActiveMinutes(logs [][]int, k int) []int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function findingUsersActiveMinutes(logs: number[][], k: number): number[] {
+    const d: Map<number, Set<number>> = new Map();
+    for (const [i, t] of logs) {
+        if (!d.has(i)) {
+            d.set(i, new Set<number>());
+        }
+        d.get(i)!.add(t);
+    }
+    const ans: number[] = Array(k).fill(0);
+    for (const [_, ts] of d) {
+        ++ans[ts.size - 1];
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```

solution/1800-1899/1817.Finding the Users Active Minutes/README_EN.md

@@ -50,6 +50,12 @@ Hence, answer[1] = 1, answer[2] = 1, and the remaining values are 0.
 
 ## Solutions
 
+**Solution 1: Hash Table**
+
+We use a hash table $d$ to record all the unique operation times of each user, and then traverse the hash table to count the number of active minutes for each user. Finally, we count the distribution of the number of active minutes for each user.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the length of the $logs$ array.
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -125,6 +131,25 @@ func findingUsersActiveMinutes(logs [][]int, k int) []int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function findingUsersActiveMinutes(logs: number[][], k: number): number[] {
+    const d: Map<number, Set<number>> = new Map();
+    for (const [i, t] of logs) {
+        if (!d.has(i)) {
+            d.set(i, new Set<number>());
+        }
+        d.get(i)!.add(t);
+    }
+    const ans: number[] = Array(k).fill(0);
+    for (const [_, ts] of d) {
+        ++ans[ts.size - 1];
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```

solution/1800-1899/1817.Finding the Users Active Minutes/Solution.ts

@@ -0,0 +1,14 @@
+function findingUsersActiveMinutes(logs: number[][], k: number): number[] {
+    const d: Map<number, Set<number>> = new Map();
+    for (const [i, t] of logs) {
+        if (!d.has(i)) {
+            d.set(i, new Set<number>());
+        }
+        d.get(i)!.add(t);
+    }
+    const ans: number[] = Array(k).fill(0);
+    for (const [_, ts] of d) {
+        ++ans[ts.size - 1];
+    }
+    return ans;
+}

solution/1800-1899/1819.Number of Different Subsequences GCDs/README.md

@@ -55,13 +55,13 @@
 
 **方法一：枚举 + 数学**
 
-对于数组 `nums` 的所有子序列，其最大公约数一定不超过数组中的最大值 $mx$。
+对于数组 $nums$ 的所有子序列，其最大公约数一定不超过数组中的最大值 $mx$。
 
-因此我们可以枚举 $[1,.. mx]$ 中的每个数 $x$，判断 $x$ 是否为数组 `nums` 的子序列的最大公约数，如果是，则答案加一。
+因此我们可以枚举 $[1,.. mx]$ 中的每个数 $x$，判断 $x$ 是否为数组 $nums$ 的子序列的最大公约数，如果是，则答案加一。
 
-那么问题转换为：判断 $x$ 是否为数组 `nums` 的子序列的最大公约数。我们可以通过枚举 $x$ 的倍数 $y$，判断 $y$ 是否在数组 `nums` 中，如果 $y$ 在数组 `nums` 中，则计算 $y$ 的最大公约数 $g$，如果出现 $g = x$，则 $x$ 是数组 `nums` 的子序列的最大公约数。
+那么问题转换为：判断 $x$ 是否为数组 $nums$ 的子序列的最大公约数。我们可以通过枚举 $x$ 的倍数 $y$，判断 $y$ 是否在数组 $nums$ 中，如果 $y$ 在数组 $nums$ 中，则计算 $y$ 的最大公约数 $g$，如果出现 $g = x$，则 $x$ 是数组 $nums$ 的子序列的最大公约数。
 
-时间复杂度 $O(n + M \times \log M)$，空间复杂度 $O(M)$。其中 $n$ 和 $M$ 分别是数组 `nums` 的长度和数组 `nums` 中的最大值。
+时间复杂度 $O(n + M \times \log M)$，空间复杂度 $O(M)$。其中 $n$ 和 $M$ 分别是数组 $nums$ 的长度和数组 $nums$ 中的最大值。
 
 <!-- tabs:start -->
 

solution/1800-1899/1826.Faulty Sensor/README.md

@@ -152,6 +152,31 @@ func badSensor(sensor1 []int, sensor2 []int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function badSensor(sensor1: number[], sensor2: number[]): number {
+    let i = 0;
+    const n = sensor1.length;
+    while (i < n - 1) {
+        if (sensor1[i] !== sensor2[i]) {
+            break;
+        }
+        ++i;
+    }
+    while (i < n - 1) {
+        if (sensor1[i + 1] !== sensor2[i]) {
+            return 1;
+        }
+        if (sensor1[i] !== sensor2[i + 1]) {
+            return 2;
+        }
+        ++i;
+    }
+    return -1;
+}
+```
+
 ### **...**
 
 ```

solution/1800-1899/1826.Faulty Sensor/README_EN.md

@@ -133,6 +133,31 @@ func badSensor(sensor1 []int, sensor2 []int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function badSensor(sensor1: number[], sensor2: number[]): number {
+    let i = 0;
+    const n = sensor1.length;
+    while (i < n - 1) {
+        if (sensor1[i] !== sensor2[i]) {
+            break;
+        }
+        ++i;
+    }
+    while (i < n - 1) {
+        if (sensor1[i + 1] !== sensor2[i]) {
+            return 1;
+        }
+        if (sensor1[i] !== sensor2[i + 1]) {
+            return 2;
+        }
+        ++i;
+    }
+    return -1;
+}
+```
+
 ### **...**
 
 ```

solution/1800-1899/1826.Faulty Sensor/Solution.ts

@@ -0,0 +1,20 @@
+function badSensor(sensor1: number[], sensor2: number[]): number {
+    let i = 0;
+    const n = sensor1.length;
+    while (i < n - 1) {
+        if (sensor1[i] !== sensor2[i]) {
+            break;
+        }
+        ++i;
+    }
+    while (i < n - 1) {
+        if (sensor1[i + 1] !== sensor2[i]) {
+            return 1;
+        }
+        if (sensor1[i] !== sensor2[i + 1]) {
+            return 2;
+        }
+        ++i;
+    }
+    return -1;
+}

solution/1800-1899/1833.Maximum Ice Cream Bars/README.md

@@ -134,6 +134,22 @@ func maxIceCream(costs []int, coins int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function maxIceCream(costs: number[], coins: number): number {
+    costs.sort((a, b) => a - b);
+    const n = costs.length;
+    for (let i = 0; i < n; ++i) {
+        if (coins < costs[i]) {
+            return i;
+        }
+        coins -= costs[i];
+    }
+    return n;
+}
+```
+
 ### **JavaScript**
 
 ```js

solution/1800-1899/1833.Maximum Ice Cream Bars/README_EN.md

@@ -51,7 +51,13 @@
 
 ## Solutions
 
-Pay attention to the data range. The question can easily mislead us to use the 01 backpack (it will overtime). In fact, this question is a simple "greedy problem" (choose low-priced ice cream first)
+**Solution 1: Greedy + Sorting**
+
+To buy as many ice creams as possible, and they can be purchased in any order, we should prioritize choosing ice creams with lower prices.
+
+Sort the $costs$ array, and then start buying from the ice cream with the lowest price, one by one, until it is no longer possible to buy, and return the number of ice creams that can be bought.
+
+The time complexity is $O(n \times \log n)$, and the space complexity is $O(\log n)$, where $n$ is the length of the $costs$ array.
 
 <!-- tabs:start -->
 
@@ -118,6 +124,22 @@ func maxIceCream(costs []int, coins int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function maxIceCream(costs: number[], coins: number): number {
+    costs.sort((a, b) => a - b);
+    const n = costs.length;
+    for (let i = 0; i < n; ++i) {
+        if (coins < costs[i]) {
+            return i;
+        }
+        coins -= costs[i];
+    }
+    return n;
+}
+```
+
 ### **JavaScript**
 
 ```js

solution/1800-1899/1833.Maximum Ice Cream Bars/Solution.ts

@@ -0,0 +1,11 @@
+function maxIceCream(costs: number[], coins: number): number {
+    costs.sort((a, b) => a - b);
+    const n = costs.length;
+    for (let i = 0; i < n; ++i) {
+        if (coins < costs[i]) {
+            return i;
+        }
+        coins -= costs[i];
+    }
+    return n;
+}