feat: add solutions to lc problems: No.1796,2489

* No.1796.Second Largest Digit in a String
* No.2489.Number of Substrings With Fixed Ratio

Author: yanglbme

solution/0800-0899/0895.Maximum Frequency Stack/README_EN.md

@@ -120,12 +120,12 @@ class FreqStack {
     public FreqStack() {
 
     }
-    
+
     public void push(int val) {
         cnt.put(val, cnt.getOrDefault(val, 0) + 1);
         q.offer(new int[] {cnt.get(val), ++ts, val});
     }
-    
+
     public int pop() {
         int val = q.poll()[2];
         cnt.put(val, cnt.get(val) - 1);
@@ -150,14 +150,14 @@ class FreqStack {
     public FreqStack() {
 
     }
-    
+
     public void push(int val) {
         cnt.put(val, cnt.getOrDefault(val, 0) + 1);
         int t = cnt.get(val);
         d.computeIfAbsent(t, k -> new ArrayDeque<>()).push(val);
         mx = Math.max(mx, t);
     }
-    
+
     public int pop() {
         int val = d.get(mx).pop();
         cnt.put(val, cnt.get(val) - 1);
@@ -184,12 +184,12 @@ public:
     FreqStack() {
 
     }
-    
+
     void push(int val) {
         ++cnt[val];
         q.emplace(cnt[val], ++ts, val);
     }
-    
+
     int pop() {
         auto [a, b, val] = q.top();
         q.pop();
@@ -217,13 +217,13 @@ public:
     FreqStack() {
 
     }
-    
+
     void push(int val) {
         ++cnt[val];
         d[cnt[val]].push(val);
         mx = max(mx, cnt[val]);
     }
-    
+
     int pop() {
         int val = d[mx].top();
         --cnt[val];

solution/0800-0899/0898.Bitwise ORs of Subarrays/README_EN.md

@@ -4,11 +4,11 @@
 
 ## Description
 
-<p>We have an array <code>arr</code> of non-negative integers.</p>
+<p>Given an integer array <code>arr</code>, return <em>the number of distinct bitwise ORs of all the non-empty subarrays of</em> <code>arr</code>.</p>
 
-<p>For every (contiguous) subarray <code>sub = [arr[i], arr[i + 1], ..., arr[j]]</code> (with <code>i &lt;= j</code>), we take the bitwise OR of all the elements in <code>sub</code>, obtaining a result <code>arr[i] | arr[i + 1] | ... | arr[j]</code>.</p>
+<p>The bitwise OR of a subarray is the bitwise OR of each integer in the subarray. The bitwise OR of a subarray of one integer is that integer.</p>
 
-<p>Return the number of possible results. Results that occur more than once are only counted once in the final answer</p>
+<p>A <strong>subarray</strong> is a contiguous non-empty sequence of elements within an array.</p>
 
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
@@ -41,8 +41,8 @@ There are 3 unique values, so the answer is 3.
 <p><strong>Constraints:</strong></p>
 
 <ul>
-	<li><code>1 &lt;= nums.length &lt;= 5 * 10<sup>4</sup></code></li>
-	<li><code>0 &lt;= nums[i]&nbsp;&lt;= 10<sup>9</sup></code></li>
+	<li><code>1 &lt;= arr.length &lt;= 5 * 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= arr[i] &lt;= 10<sup>9</sup></code></li>
 </ul>
 
 ## Solutions

solution/0900-0999/0976.Largest Perimeter Triangle/README_EN.md

@@ -12,13 +12,19 @@
 <pre>
 <strong>Input:</strong> nums = [2,1,2]
 <strong>Output:</strong> 5
+<strong>Explanation:</strong> You can form a triangle with three side lengths: 1, 2, and 2.
 </pre>
 
 <p><strong class="example">Example 2:</strong></p>
 
 <pre>
-<strong>Input:</strong> nums = [1,2,1]
+<strong>Input:</strong> nums = [1,2,1,10]
 <strong>Output:</strong> 0
+<strong>Explanation:</strong> 
+You cannot use the side lengths 1, 1, and 2 to form a triangle.
+You cannot use the side lengths 1, 1, and 10 to form a triangle.
+You cannot use the side lengths 1, 2, and 10 to form a triangle.
+As we cannot use any three side lengths to form a triangle of non-zero area, we return 0.
 </pre>
 
 <p>&nbsp;</p>

solution/1000-1099/1027.Longest Arithmetic Subsequence/README_EN.md

@@ -4,36 +4,38 @@
 
 ## Description
 
-<p>Given an array <code>nums</code> of integers, return the <strong>length</strong> of the longest arithmetic subsequence in <code>nums</code>.</p>
+<p>Given an array <code>nums</code> of integers, return <em>the length of the longest arithmetic subsequence in</em> <code>nums</code>.</p>
 
-<p>Recall that a <em>subsequence</em> of an array <code>nums</code> is a list <code>nums[i<sub>1</sub>], nums[i<sub>2</sub>], ..., nums[i<sub>k</sub>]</code> with <code>0 &lt;= i<sub>1</sub> &lt; i<sub>2</sub> &lt; ... &lt; i<sub>k</sub> &lt;= nums.length - 1</code>, and that a sequence <code>seq</code> is <em>arithmetic</em> if <code>seq[i+1] - seq[i]</code> are all the same value (for <code>0 &lt;= i &lt; seq.length - 1</code>).</p>
+<p><strong>Note</strong> that:</p>
+
+<ul>
+	<li>A <strong>subsequence</strong> is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.</li>
+	<li>A sequence <code>seq</code> is arithmetic if <code>seq[i + 1] - seq[i]</code> are all the same value (for <code>0 &lt;= i &lt; seq.length - 1</code>).</li>
+</ul>
 
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 
 <pre>
 <strong>Input:</strong> nums = [3,6,9,12]
 <strong>Output:</strong> 4
-<strong>Explanation: </strong>
-The whole array is an arithmetic sequence with steps of length = 3.
+<strong>Explanation: </strong> The whole array is an arithmetic sequence with steps of length = 3.
 </pre>
 
 <p><strong class="example">Example 2:</strong></p>
 
 <pre>
 <strong>Input:</strong> nums = [9,4,7,2,10]
 <strong>Output:</strong> 3
-<strong>Explanation: </strong>
-The longest arithmetic subsequence is [4,7,10].
+<strong>Explanation: </strong> The longest arithmetic subsequence is [4,7,10].
 </pre>
 
 <p><strong class="example">Example 3:</strong></p>
 
 <pre>
 <strong>Input:</strong> nums = [20,1,15,3,10,5,8]
 <strong>Output:</strong> 4
-<strong>Explanation: </strong>
-The longest arithmetic subsequence is [20,15,10,5].
+<strong>Explanation: </strong> The longest arithmetic subsequence is [20,15,10,5].
 </pre>
 
 <p>&nbsp;</p>

solution/1200-1299/1207.Unique Number of Occurrences/README_EN.md

@@ -4,7 +4,7 @@
 
 ## Description
 
-<p>Given an array of integers <code>arr</code>, return <code>true</code> if the number of occurrences of each value in the array is <strong>unique</strong>, or <code>false</code> otherwise.</p>
+<p>Given an array of integers <code>arr</code>, return <code>true</code> <em>if the number of occurrences of each value in the array is <strong>unique</strong> or </em><code>false</code><em> otherwise</em>.</p>
 
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
@@ -32,7 +32,7 @@
 <p><strong>Constraints:</strong></p>
 
 <ul>
-	<li><code>1 &lt;= arr.length&nbsp;&lt;= 1000</code></li>
+	<li><code>1 &lt;= arr.length &lt;= 1000</code></li>
 	<li><code>-1000 &lt;= arr[i] &lt;= 1000</code></li>
 </ul>
 

solution/1700-1799/1729.Find Followers Count/README_EN.md

@@ -20,7 +20,7 @@ This table contains the IDs of a user and a follower in a social media app where
 
 <p>Write an SQL query that will, for each user, return the number of followers.</p>
 
-<p>Return the result table ordered by <code>user_id</code>.</p>
+<p>Return the result table ordered by <code>user_id</code> in ascending order.</p>
 
 <p>The query result format is in the following example.</p>
 

solution/1700-1799/1769.Minimum Number of Operations to Move All Balls to Each Box/README.md

@@ -47,13 +47,13 @@
 
 **方法一：预处理 + 枚举**
 
-我们可以预处理出把每个位置 $i$ 左边的小球移动到 $i$ 的操作数，记为 $left[i]$；把每个位置 $i$ 右边的小球移动到 $i$ 的操作数，记为 $right[i]$。那么答案数组的第 $i$ 个元素就是 $left[i] + right[i]$。
+我们可以预处理出每个位置 $i$ 左边的小球移动到 $i$ 的操作数，记为 $left[i]$；每个位置 $i$ 右边的小球移动到 $i$ 的操作数，记为 $right[i]$。那么答案数组的第 $i$ 个元素就是 $left[i] + right[i]$。
 
 时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为 `boxes` 的长度。
 
 我们还可以进一步优化空间复杂度，只用一个答案数组 $ans$ 以及若干个变量即可。
 
-时间复杂度 $O(n)$，忽略答案数组的空间复杂度，空间复杂度 $O(1)$。其中 $n$ 为 `boxes` 的长度。
+时间复杂度 $O(n)$，忽略答案数组的空间消耗，空间复杂度 $O(1)$。其中 $n$ 为 `boxes` 的长度。
 
 <!-- tabs:start -->
 

solution/1700-1799/1796.Second Largest Digit in a String/README.md

@@ -41,15 +41,25 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-假设字符串最大的数为 `largestDigit`，第二大的数为 `secondLargestDigit`，初始化均为 -1。
+**方法一：一次遍历**
 
-遍历字符串，判断当前字符是否为数字型字符。若是，先转为数字 `num`。然后判断数字与 `largestDigit`、`secondLargestDigit` 的大小关系：
+我们定义 $a$ 和 $b$ 分别表示字符串中出现的最大数字和第二大数字，初始时 $a = b = -1$。
 
--   若 `num > largestDigit`，将 `secondLargestDigit` 更新为 `largestDigit`，而 `largestDigit` 更新为 num；
--   若 `num > secondLargestDigit`，并且 `num < largestDigit`，将 `secondLargestDigit` 更新为 num；
--   其他情况不做处理。
+遍历字符串 $s$，如果当前字符是数字，我们将其转换为数字 $v$，如果 $v \gt a$，说明 $v$ 是当前出现的最大数字，我们将 $b$ 更新为 $a$，并将 $a$ 更新为 $v$；如果 $v \lt a$，说明 $v$ 是当前出现的第二大数字，我们将 $b$ 更新为 $v$。
 
-最后返回 `secondLargestDigit` 即可。
+遍历结束，返回 $b$ 即可。
+
+时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为字符串 $s$ 的长度。
+
+**方法二：位运算**
+
+我们可以用一个整数 $mask$ 来标识字符串中出现的数字，其中 $mask$ 的第 $i$ 位表示数字 $i$ 是否出现过。
+
+遍历字符串 $s$，如果当前字符是数字，我们将其转换为数字 $v$，将 $mask$ 的第 $v$ 个二进制位的值置为 $1$。
+
+最后，我们从高位向低位遍历 $mask$，找到第二个为 $1$ 的二进制位，其对应的数字即为第二大数字。如果不存在第二大数字，返回 $-1$。
+
+时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为字符串 $s$ 的长度。
 
 <!-- tabs:start -->
 
@@ -60,15 +70,28 @@
 ```python
 class Solution:
     def secondHighest(self, s: str) -> int:
-        largest_digit = second_largest_digit = -1
+        a = b = -1
         for c in s:
             if c.isdigit():
-                num = int(c)
-                if num > largest_digit:
-                    second_largest_digit, largest_digit = largest_digit, num
-                elif num > second_largest_digit and num < largest_digit:
-                    second_largest_digit = num
-        return second_largest_digit
+                v = int(c)
+                if v > a:
+                    a, b = v, a
+                elif b < v < a:
+                    b = v
+        return b
+```
+
+```python
+class Solution:
+    def secondHighest(self, s: str) -> int:
+        mask = reduce(or_, (1 << int(c) for c in s if c.isdigit()), 0)
+        cnt = 0
+        for i in range(9, -1, -1):
+            if (mask >> i) & 1:
+                cnt += 1
+            if cnt == 2:
+                return i
+        return -1
 ```
 
 ### **Java**
@@ -78,21 +101,114 @@ class Solution:
 ```java
 class Solution {
     public int secondHighest(String s) {
-        int largestDigit = -1, secondLargestDigit = -1;
+        int a = -1, b = -1;
+        for (int i = 0; i < s.length(); ++i) {
+            char c = s.charAt(i);
+            if (Character.isDigit(c)) {
+                int v = c - '0';
+                if (v > a) {
+                    b = a;
+                    a = v;
+                } else if (v > b && v < a) {
+                    b = v;
+                }
+            }
+        }
+        return b;
+    }
+}
+```
+
+```java
+class Solution {
+    public int secondHighest(String s) {
+        int mask = 0;
         for (int i = 0; i < s.length(); ++i) {
             char c = s.charAt(i);
-            if (c >= '0' && c <= '9') {
-                int num = c - '0';
-                if (num > largestDigit) {
-                    secondLargestDigit = largestDigit;
-                    largestDigit = num;
-                } else if (num > secondLargestDigit && num < largestDigit) {
-                    secondLargestDigit = num;
+            if (Character.isDigit(c)) {
+                mask |= 1 << (c - '0');
+            }
+        }
+        for (int i = 9, cnt = 0; i >= 0; --i) {
+            if (((mask >> i) & 1) == 1 && ++cnt == 2) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int secondHighest(string s) {
+        int a = -1, b = -1;
+        for (char& c : s) {
+            if (isdigit(c)) {
+                int v = c - '0';
+                if (v > a) {
+                    b = a, a = v;
+                } else if (v > b && v < a) {
+                    b = v;
                 }
             }
         }
-        return secondLargestDigit;
+        return b;
+    }
+};
+```
+
+```cpp
+class Solution {
+public:
+    int secondHighest(string s) {
+        int mask = 0;
+        for (char& c : s) if (isdigit(c)) mask |= 1 << c - '0';
+        for (int i = 9, cnt = 0; ~i; --i) if (mask >> i & 1 && ++cnt == 2) return i;
+        return -1;
     }
+};
+```
+
+### **Go**
+
+```go
+func secondHighest(s string) int {
+	a, b := -1, -1
+	for _, c := range s {
+		if c >= '0' && c <= '9' {
+			v := int(c - '0')
+			if v > a {
+				b, a = a, v
+			} else if v > b && v < a {
+				b = v
+			}
+		}
+	}
+	return b
+}
+```
+
+```go
+func secondHighest(s string) int {
+	mask := 0
+	for _, c := range s {
+		if c >= '0' && c <= '9' {
+			mask |= 1 << int(c-'0')
+		}
+	}
+	for i, cnt := 9, 0; i >= 0; i-- {
+		if mask>>i&1 == 1 {
+			cnt++
+			if cnt == 2 {
+				return i
+			}
+		}
+	}
+	return -1
 }
 ```