feat: add solutions to lc problems: No.3174,3175,3182

solution/1500-1599/1535.Find the Winner of an Array Game/README.md

@@ -80,6 +80,10 @@ tags:
 
 时间复杂度 $O(n)$，其中 $n$ 是数组的长度。空间复杂度 $O(1)$。
 
+相似题目：
+
+-   [3175. 找到连续赢 K 场比赛的第一位玩家](https://github.com/doocs/leetcode/blob/main/solution/3100-3199/3175.Find%20The%20First%20Player%20to%20win%20K%20Games%20in%20a%20Row/README.md)
+
 <!-- tabs:start -->
 
 #### Python3

solution/1500-1599/1535.Find the Winner of an Array Game/README_EN.md

@@ -66,7 +66,15 @@ So we can see that 4 rounds will be played and 5 is the winner because it wins 2
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Quick Thinking
+
+We notice that each time the first two elements of the array are compared, regardless of the result, the next comparison will always be between the next element in the array and the current winner. Therefore, if we have looped $n-1$ times, the final winner must be the maximum element in the array. Otherwise, if an element has won consecutively $k$ times, then this element is the final winner.
+
+The time complexity is $O(n)$, where $n$ is the length of the array. The space complexity is $O(1)$.
+
+Similar problems:
+
+-   [1535. Find the Winner of an Array Game](https://github.com/doocs/leetcode/blob/main/solution/3100-3199/3175.Find%20The%20First%20Player%20to%20win%20K%20Games%20in%20a%20Row/README_EN.md)
 
 <!-- tabs:start -->
 

solution/3100-3199/3174.Clear Digits/README.md

@@ -68,32 +68,97 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3100-3199/3174.Cl
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：栈 + 模拟
+
+我们用一个栈 `stk` 来模拟这个过程，遍历字符串 `s`，如果当前字符是数字，就弹出栈顶元素，否则将当前字符入栈。
+
+最后将栈中的元素拼接成字符串返回。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为字符串 `s` 的长度。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def clearDigits(self, s: str) -> str:
+        stk = []
+        for c in s:
+            if c.isdigit():
+                stk.pop()
+            else:
+                stk.append(c)
+        return "".join(stk)
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public String clearDigits(String s) {
+        StringBuilder stk = new StringBuilder();
+        for (char c : s.toCharArray()) {
+            if (Character.isDigit(c)) {
+                stk.deleteCharAt(stk.length() - 1);
+            } else {
+                stk.append(c);
+            }
+        }
+        return stk.toString();
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    string clearDigits(string s) {
+        string stk;
+        for (char c : s) {
+            if (isdigit(c)) {
+                stk.pop_back();
+            } else {
+                stk.push_back(c);
+            }
+        }
+        return stk;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func clearDigits(s string) string {
+	stk := []byte{}
+	for i := range s {
+		if s[i] >= '0' && s[i] <= '9' {
+			stk = stk[:len(stk)-1]
+		} else {
+			stk = append(stk, s[i])
+		}
+	}
+	return string(stk)
+}
+```
 
+#### TypeScript
+
+```ts
+function clearDigits(s: string): string {
+    const stk: string[] = [];
+    for (const c of s) {
+        if (!isNaN(parseInt(c))) {
+            stk.pop();
+        } else {
+            stk.push(c);
+        }
+    }
+    return stk.join('');
+}
 ```
 
 <!-- tabs:end -->

solution/3100-3199/3174.Clear Digits/README_EN.md

@@ -66,32 +66,97 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3100-3199/3174.Cl
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Stack + Simulation
+
+We use a stack `stk` to simulate this process. We traverse the string `s`. If the current character is a digit, we pop the top element from the stack. Otherwise, we push the current character into the stack.
+
+Finally, we concatenate the elements in the stack into a string and return it.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Where $n$ is the length of the string `s`.
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def clearDigits(self, s: str) -> str:
+        stk = []
+        for c in s:
+            if c.isdigit():
+                stk.pop()
+            else:
+                stk.append(c)
+        return "".join(stk)
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public String clearDigits(String s) {
+        StringBuilder stk = new StringBuilder();
+        for (char c : s.toCharArray()) {
+            if (Character.isDigit(c)) {
+                stk.deleteCharAt(stk.length() - 1);
+            } else {
+                stk.append(c);
+            }
+        }
+        return stk.toString();
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    string clearDigits(string s) {
+        string stk;
+        for (char c : s) {
+            if (isdigit(c)) {
+                stk.pop_back();
+            } else {
+                stk.push_back(c);
+            }
+        }
+        return stk;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func clearDigits(s string) string {
+	stk := []byte{}
+	for i := range s {
+		if s[i] >= '0' && s[i] <= '9' {
+			stk = stk[:len(stk)-1]
+		} else {
+			stk = append(stk, s[i])
+		}
+	}
+	return string(stk)
+}
+```
 
+#### TypeScript
+
+```ts
+function clearDigits(s: string): string {
+    const stk: string[] = [];
+    for (const c of s) {
+        if (!isNaN(parseInt(c))) {
+            stk.pop();
+        } else {
+            stk.push(c);
+        }
+    }
+    return stk.join('');
+}
 ```
 
 <!-- tabs:end -->

solution/3100-3199/3174.Clear Digits/Solution.cpp

@@ -0,0 +1,14 @@
+class Solution {
+public:
+    string clearDigits(string s) {
+        string stk;
+        for (char c : s) {
+            if (isdigit(c)) {
+                stk.pop_back();
+            } else {
+                stk.push_back(c);
+            }
+        }
+        return stk;
+    }
+};

solution/3100-3199/3174.Clear Digits/Solution.go

@@ -0,0 +1,11 @@
+func clearDigits(s string) string {
+	stk := []byte{}
+	for i := range s {
+		if s[i] >= '0' && s[i] <= '9' {
+			stk = stk[:len(stk)-1]
+		} else {
+			stk = append(stk, s[i])
+		}
+	}
+	return string(stk)
+}

solution/3100-3199/3174.Clear Digits/Solution.java

@@ -0,0 +1,13 @@
+class Solution {
+    public String clearDigits(String s) {
+        StringBuilder stk = new StringBuilder();
+        for (char c : s.toCharArray()) {
+            if (Character.isDigit(c)) {
+                stk.deleteCharAt(stk.length() - 1);
+            } else {
+                stk.append(c);
+            }
+        }
+        return stk.toString();
+    }
+}

solution/3100-3199/3174.Clear Digits/Solution.py

@@ -0,0 +1,9 @@
+class Solution:
+    def clearDigits(self, s: str) -> str:
+        stk = []
+        for c in s:
+            if c.isdigit():
+                stk.pop()
+            else:
+                stk.append(c)
+        return "".join(stk)

solution/3100-3199/3174.Clear Digits/Solution.ts

@@ -0,0 +1,11 @@
+function clearDigits(s: string): string {
+    const stk: string[] = [];
+    for (const c of s) {
+        if (!isNaN(parseInt(c))) {
+            stk.pop();
+        } else {
+            stk.push(c);
+        }
+    }
+    return stk.join('');
+}