feat: add solutions to lc problem: No.1702 (#2565)

No.1702.Maximum Binary String After Change

Author: yanglbme

solution/1700-1799/1702.Maximum Binary String After Change/README.md

@@ -63,11 +63,13 @@
 
 ### 方法一：脑筋急转弯
 
-我们观察发现，操作 2 可以把所有的 $1$ 都移动到字符串的末尾，而操作 1 可以把所有的 `0000..000` 串变为 `111..110`。
+我们观察发现，操作 $2$ 可以把所有的 $1$ 都移动到字符串的末尾，而操作 $1$ 可以把所有的 `0000..000` 串变为 `111..110`。
 
-因此，要想得到最大的二进制串，我们应该把所有不在开头的 $1$ 移动到字符串末尾，使得字符串变为 `111..11...00..11` 的形式，然后借助操作 1 把中间的 `000..00` 变为 `111..10`。这样我们最终可以得到一个最多包含一个 $0$ 的二进制字符串，这个字符串就是我们要求的最大二进制串。
+因此，要想得到最大的二进制串，我们应该把所有不在开头的 $1$ 移动到字符串末尾，使得字符串变为 `111..11...000..00..11` 的形式，然后借助操作 $1$ 把中间的 `000..00` 变为 `111..10`。这样我们最终可以得到一个最多包含一个 $0$ 的二进制字符串，这个字符串就是我们要求的最大二进制串。
 
-时间复杂度 $O(n)$，其中 $n$ 为字符串 `binary` 的长度。忽略答案的空间消耗，空间复杂度 $O(1)$。
+在代码实现上，我们首先判断字符串是否包含 $0$，如果不包含，直接返回原字符串。否则，我们找到第一个 $0$ 的位置 $k$，加上该位置之后的 $0$ 的个数，得到的就是修改后的字符串的 $0$ 所在的位置，其余位置都是 $1$。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是字符串的长度。
 
 <!-- tabs:start -->
 
@@ -107,7 +109,9 @@ class Solution {
 public:
     string maximumBinaryString(string binary) {
         int k = binary.find('0');
-        if (k == binary.npos) return binary;
+        if (k == binary.npos) {
+            return binary;
+        }
         int n = binary.size();
         for (int i = k + 1; i < n; ++i) {
             if (binary[i] == '0') {
@@ -139,6 +143,47 @@ func maximumBinaryString(binary string) string {
 }
 ```
 
+```ts
+function maximumBinaryString(binary: string): string {
+    let k = binary.indexOf('0');
+    if (k === -1) {
+        return binary;
+    }
+    k += binary.slice(k + 1).split('0').length - 1;
+    return '1'.repeat(k) + '0' + '1'.repeat(binary.length - k - 1);
+}
+```
+
+```rust
+impl Solution {
+    pub fn maximum_binary_string(binary: String) -> String {
+        if let Some(k) = binary.find('0') {
+            let k =
+                k +
+                binary[k + 1..]
+                    .chars()
+                    .filter(|&c| c == '0')
+                    .count();
+            return format!("{}{}{}", "1".repeat(k), "0", "1".repeat(binary.len() - k - 1));
+        }
+        binary
+    }
+}
+```
+
+```cs
+public class Solution {
+    public string MaximumBinaryString(string binary) {
+        int k = binary.IndexOf('0');
+        if (k == -1) {
+            return binary;
+        }
+        k += binary.Substring(k + 1).Count(c => c == '0');
+        return new string('1', k) + '0' + new string('1', binary.Length - k - 1);
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- end -->

solution/1700-1799/1702.Maximum Binary String After Change/README_EN.md

@@ -59,11 +59,13 @@
 
 ### Solution 1: Quick Thinking
 
-We observe that operation 2 can move all $1$s to the end of the string, and operation 1 can change all `0000..000` strings to `111..110`.
+We observe that operation $2$ can move all $1$s to the end of the string, and operation $1$ can change all `0000..000` strings to `111..110`.
 
-Therefore, to get the maximum binary string, we should move all $1$s that are not at the beginning to the end of the string, making the string in the form of `111..11...00..11`, and then use operation 1 to change the middle `000..00` to `111..10`. In this way, we can finally get a binary string that contains at most one $0$, which is the maximum binary string we are looking for.
+Therefore, to get the maximum binary string, we should move all $1$s that are not at the beginning to the end of the string, making the string in the form of `111..11...000..00..11`. Then, with the help of operation $1$, we change the middle `000..00` to `111..10`. In this way, we can finally get a binary string that contains at most one $0$, which is the maximum binary string we are looking for.
 
-The time complexity is $O(n)$, where $n$ is the length of the string `binary`. Ignoring the space consumption of the answer, the space complexity is $O(1)$.
+In the code implementation, we first judge whether the string contains $0$. If it does not, we directly return the original string. Otherwise, we find the position $k$ of the first $0$, add the number of $0$s after this position, and the position of $0$ in the modified string is obtained. The rest of the positions are all $1$s.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Where $n$ is the length of the string.
 
 <!-- tabs:start -->
 
@@ -103,7 +105,9 @@ class Solution {
 public:
     string maximumBinaryString(string binary) {
         int k = binary.find('0');
-        if (k == binary.npos) return binary;
+        if (k == binary.npos) {
+            return binary;
+        }
         int n = binary.size();
         for (int i = k + 1; i < n; ++i) {
             if (binary[i] == '0') {
@@ -135,6 +139,47 @@ func maximumBinaryString(binary string) string {
 }
 ```
 
+```ts
+function maximumBinaryString(binary: string): string {
+    let k = binary.indexOf('0');
+    if (k === -1) {
+        return binary;
+    }
+    k += binary.slice(k + 1).split('0').length - 1;
+    return '1'.repeat(k) + '0' + '1'.repeat(binary.length - k - 1);
+}
+```
+
+```rust
+impl Solution {
+    pub fn maximum_binary_string(binary: String) -> String {
+        if let Some(k) = binary.find('0') {
+            let k =
+                k +
+                binary[k + 1..]
+                    .chars()
+                    .filter(|&c| c == '0')
+                    .count();
+            return format!("{}{}{}", "1".repeat(k), "0", "1".repeat(binary.len() - k - 1));
+        }
+        binary
+    }
+}
+```
+
+```cs
+public class Solution {
+    public string MaximumBinaryString(string binary) {
+        int k = binary.IndexOf('0');
+        if (k == -1) {
+            return binary;
+        }
+        k += binary.Substring(k + 1).Count(c => c == '0');
+        return new string('1', k) + '0' + new string('1', binary.Length - k - 1);
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- end -->

solution/1700-1799/1702.Maximum Binary String After Change/Solution.cpp

@@ -2,7 +2,9 @@ class Solution {
 public:
     string maximumBinaryString(string binary) {
         int k = binary.find('0');
-        if (k == binary.npos) return binary;
+        if (k == binary.npos) {
+            return binary;
+        }
         int n = binary.size();
         for (int i = k + 1; i < n; ++i) {
             if (binary[i] == '0') {

solution/1700-1799/1702.Maximum Binary String After Change/Solution.cs

@@ -0,0 +1,10 @@
+public class Solution {
+    public string MaximumBinaryString(string binary) {
+        int k = binary.IndexOf('0');
+        if (k == -1) {
+            return binary;
+        }
+        k += binary.Substring(k + 1).Count(c => c == '0');
+        return new string('1', k) + '0' + new string('1', binary.Length - k - 1);
+    }
+}

solution/1700-1799/1702.Maximum Binary String After Change/Solution.rs

@@ -0,0 +1,14 @@
+impl Solution {
+    pub fn maximum_binary_string(binary: String) -> String {
+        if let Some(k) = binary.find('0') {
+            let k =
+                k +
+                binary[k + 1..]
+                    .chars()
+                    .filter(|&c| c == '0')
+                    .count();
+            return format!("{}{}{}", "1".repeat(k), "0", "1".repeat(binary.len() - k - 1));
+        }
+        binary
+    }
+}

solution/1700-1799/1702.Maximum Binary String After Change/Solution.ts

@@ -0,0 +1,8 @@
+function maximumBinaryString(binary: string): string {
+    let k = binary.indexOf('0');
+    if (k === -1) {
+        return binary;
+    }
+    k += binary.slice(k + 1).split('0').length - 1;
+    return '1'.repeat(k) + '0' + '1'.repeat(binary.length - k - 1);
+}