feat: add solutions to lc problem: No.2038

No.2038.Remove Colored Pieces if Both Neighbors are the Same Color

Author: yanglbme

solution/2000-2099/2038.Remove Colored Pieces if Both Neighbors are the Same Color/README.md

@@ -94,11 +94,11 @@ ABBBB<strong><em>B</em></strong>BBAA -&gt; ABBBBBBAA
 
 ### 方法一：计数
 
-我们统计字符串 `colors` 中连续出现 $3$ 个 `'A'` 或 $3$ 个 `'B'` 的个数，分别记为 $a$ 和 $b$。
+我们可以遍历字符串 $\textit{colors}$，找出每一个连续出现的字符段，记该字符串长度减去 $2$ 的值为 $m$，如果该段字符是 `'A'`，则将 $m$ 加入计数器 $a$，如果该段字符是 `'B'`，则将 $m$ 加入计数器 $b$。
 
-最后判断 $a$ 是否大于 $b$，是则返回 `true`，否则返回 `false`。
+最后判断 $a$ 是否大于 $b$，如果是，则 Alice 获胜，返回 $\textit{true}$；否则 Bob 获胜，返回 $\textit{false}$。
 
-时间复杂度 $O(n)$，其中 $n$ 为字符串 `colors` 的长度。空间复杂度 $O(1)$。
+时间复杂度 $O(n)$，其中 $n$ 为字符串 $\textit{colors}$ 的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -214,6 +214,39 @@ function winnerOfGame(colors: string): boolean {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn winner_of_game(colors: String) -> bool {
+        let n = colors.len();
+        let s = colors.as_bytes();
+        let mut a = 0i32;
+        let mut b = 0i32;
+        let mut i = 0usize;
+        let mut j;
+
+        while i < n {
+            j = i;
+            while j < n && s[j] == s[i] {
+                j += 1;
+            }
+            let m = j as i32 - i as i32 - 2;
+            if m > 0 {
+                if s[i] == b'A' {
+                    a += m;
+                } else {
+                    b += m;
+                }
+            }
+            i = j;
+        }
+
+        a > b
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2000-2099/2038.Remove Colored Pieces if Both Neighbors are the Same Color/README_EN.md

@@ -95,11 +95,17 @@ Thus, Bob wins, so return false.
 
 ### Solution 1: Counting
 
-We count the number of times that the string `colors` contains three consecutive `'A'`s or three consecutive `'B'`s, denoted as $a$ and $b$, respectively.
+We can traverse the string $\textit{colors}$ and identify every contiguous block of identical characters. For each block, let its length minus $2$ be $m$.
 
-Finally, we check whether $a$ is greater than $b$. If it is, we return `true`. Otherwise, we return `false`.
+-   If the block consists of `'A'`, add $m$ to counter $a$.
+-   If the block consists of `'B'`, add $m$ to counter $b$.
 
-The time complexity is $O(n)$, where $n$ is the length of the string `colors`. The space complexity is $O(1)$.
+Finally, check whether $a > b$.
+
+-   If so, Alice wins and we return $\textit{true}$.
+-   Otherwise, Bob wins and we return $\textit{false}$.
+
+The time complexity is $O(n)$, where $n$ is the length of $\textit{colors}$, and the space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
@@ -215,6 +221,39 @@ function winnerOfGame(colors: string): boolean {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn winner_of_game(colors: String) -> bool {
+        let n = colors.len();
+        let s = colors.as_bytes();
+        let mut a = 0i32;
+        let mut b = 0i32;
+        let mut i = 0usize;
+        let mut j;
+
+        while i < n {
+            j = i;
+            while j < n && s[j] == s[i] {
+                j += 1;
+            }
+            let m = j as i32 - i as i32 - 2;
+            if m > 0 {
+                if s[i] == b'A' {
+                    a += m;
+                } else {
+                    b += m;
+                }
+            }
+            i = j;
+        }
+
+        a > b
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2000-2099/2038.Remove Colored Pieces if Both Neighbors are the Same Color/Solution.rs

@@ -0,0 +1,28 @@
+impl Solution {
+    pub fn winner_of_game(colors: String) -> bool {
+        let n = colors.len();
+        let s = colors.as_bytes();
+        let mut a = 0i32;
+        let mut b = 0i32;
+        let mut i = 0usize;
+        let mut j;
+
+        while i < n {
+            j = i;
+            while j < n && s[j] == s[i] {
+                j += 1;
+            }
+            let m = j as i32 - i as i32 - 2;
+            if m > 0 {
+                if s[i] == b'A' {
+                    a += m;
+                } else {
+                    b += m;
+                }
+            }
+            i = j;
+        }
+
+        a > b
+    }
+}