+ problem 2434

Author: fruit-in

Problemset/2434-Using a Robot to Print the Lexicographically Smallest String/README.md

@@ -0,0 +1,79 @@
+# 2434. Using a Robot to Print the Lexicographically Smallest String
+You are given a string `s` and a robot that currently holds an empty string `t`. Apply one of the following operations until `s` and `t` **are both empty**:
+
+* Remove the **first** character of a string `s` and give it to the robot. The robot will append this character to the string `t`.
+* Remove the **last** character of a string `t` and give it to the robot. The robot will write this character on paper.
+
+Return *the lexicographically smallest string that can be written on the paper*.
+
+#### Example 1:
+<pre>
+<strong>Input:</strong> s = "zza"
+<strong>Output:</strong> "azz"
+<strong>Explanation:</strong> Let p denote the written string.
+Initially p="", s="zza", t="".
+Perform first operation three times p="", s="", t="zza".
+Perform second operation three times p="azz", s="", t="".
+</pre>
+
+#### Example 2:
+<pre>
+<strong>Input:</strong> s = "bac"
+<strong>Output:</strong> "abc"
+<strong>Explanation:</strong> Let p denote the written string.
+Perform first operation twice p="", s="c", t="ba".
+Perform second operation twice p="ab", s="c", t="".
+Perform first operation p="ab", s="", t="c".
+Perform second operation p="abc", s="", t="".
+</pre>
+
+#### Example 3:
+<pre>
+<strong>Input:</strong> s = "bdda"
+<strong>Output:</strong> "addb"
+<strong>Explanation:</strong> Let p denote the written string.
+Initially p="", s="bdda", t="".
+Perform first operation four times p="", s="", t="bdda".
+Perform second operation four times p="addb", s="", t="".
+</pre>
+
+#### Constraints:
+* <code>1 <= s.length <= 10<sup>5</sup></code>
+* `s` consists of only English lowercase letters.
+
+## Solutions (Rust)
+
+### 1. Solution
+```Rust
+impl Solution {
+    pub fn robot_with_string(s: String) -> String {
+        let mut s = s.bytes().rev().collect::<Vec<_>>();
+        let mut t = vec![];
+        let mut p = vec![];
+        let mut count = [0; 26];
+
+        for &ch in &s {
+            count[(ch - b'a') as usize] += 1;
+        }
+
+        while let Some(ch0) = s.pop() {
+            count[(ch0 - b'a') as usize] -= 1;
+            t.push(ch0);
+
+            while let Some(&ch1) = t.last() {
+                if count.iter().take((ch1 - b'a') as usize).all(|&x| x == 0) {
+                    p.push(t.pop().unwrap());
+                } else {
+                    break;
+                }
+            }
+        }
+
+        while let Some(ch) = t.pop() {
+            p.push(ch);
+        }
+
+        String::from_utf8(p).unwrap()
+    }
+}
+```

Problemset/2434-Using a Robot to Print the Lexicographically Smallest String/README_CN.md

@@ -0,0 +1,79 @@
+# 2434. 使用机器人打印字典序最小的字符串
+给你一个字符串 `s` 和一个机器人，机器人当前有一个空字符串 `t` 。执行以下操作之一，直到 `s` 和 `t` **都变成空字符串**：
+
+* 删除字符串 `s` 的 **第一个** 字符，并将该字符给机器人。机器人把这个字符添加到 `t` 的尾部。
+* 删除字符串 `t` 的 **最后一个** 字符，并将该字符给机器人。机器人将该字符写到纸上。
+
+请你返回纸上能写出的字典序最小的字符串。
+
+#### 示例 1:
+<pre>
+<strong>输入:</strong> s = "zza"
+<strong>输出:</strong> "azz"
+<strong>解释:</strong> 用 p 表示写出来的字符串。
+一开始，p="" ，s="zza" ，t="" 。
+执行第一个操作三次，得到 p="" ，s="" ，t="zza" 。
+执行第二个操作三次，得到 p="azz" ，s="" ，t="" 。
+</pre>
+
+#### 示例 2:
+<pre>
+<strong>输入:</strong> s = "bac"
+<strong>输出:</strong> "abc"
+<strong>解释:</strong> 用 p 表示写出来的字符串。
+执行第一个操作两次，得到 p="" ，s="c" ，t="ba" 。
+执行第二个操作两次，得到 p="ab" ，s="c" ，t="" 。
+执行第一个操作，得到 p="ab" ，s="" ，t="c" 。
+执行第二个操作，得到 p="abc" ，s="" ，t="" 。
+</pre>
+
+#### 示例 3:
+<pre>
+<strong>输入:</strong> s = "bdda"
+<strong>输出:</strong> "addb"
+<strong>Explanation:</strong> 用 p 表示写出来的字符串。
+一开始，p="" ，s="bdda" ，t="" 。
+执行第一个操作四次，得到 p="" ，s="" ，t="bdda" 。
+执行第二个操作四次，得到 p="addb" ，s="" ，t="" 。
+</pre>
+
+#### 提示:
+* <code>1 <= s.length <= 10<sup>5</sup></code>
+* `s` 只包含小写英文字母。
+
+## 题解 (Rust)
+
+### 1. 题解
+```Rust
+impl Solution {
+    pub fn robot_with_string(s: String) -> String {
+        let mut s = s.bytes().rev().collect::<Vec<_>>();
+        let mut t = vec![];
+        let mut p = vec![];
+        let mut count = [0; 26];
+
+        for &ch in &s {
+            count[(ch - b'a') as usize] += 1;
+        }
+
+        while let Some(ch0) = s.pop() {
+            count[(ch0 - b'a') as usize] -= 1;
+            t.push(ch0);
+
+            while let Some(&ch1) = t.last() {
+                if count.iter().take((ch1 - b'a') as usize).all(|&x| x == 0) {
+                    p.push(t.pop().unwrap());
+                } else {
+                    break;
+                }
+            }
+        }
+
+        while let Some(ch) = t.pop() {
+            p.push(ch);
+        }
+
+        String::from_utf8(p).unwrap()
+    }
+}
+```

Problemset/2434-Using a Robot to Print the Lexicographically Smallest String/Solution.rs

@@ -0,0 +1,31 @@
+impl Solution {
+    pub fn robot_with_string(s: String) -> String {
+        let mut s = s.bytes().rev().collect::<Vec<_>>();
+        let mut t = vec![];
+        let mut p = vec![];
+        let mut count = [0; 26];
+
+        for &ch in &s {
+            count[(ch - b'a') as usize] += 1;
+        }
+
+        while let Some(ch0) = s.pop() {
+            count[(ch0 - b'a') as usize] -= 1;
+            t.push(ch0);
+
+            while let Some(&ch1) = t.last() {
+                if count.iter().take((ch1 - b'a') as usize).all(|&x| x == 0) {
+                    p.push(t.pop().unwrap());
+                } else {
+                    break;
+                }
+            }
+        }
+
+        while let Some(ch) = t.pop() {
+            p.push(ch);
+        }
+
+        String::from_utf8(p).unwrap()
+    }
+}

README.md

@@ -1109,6 +1109,7 @@
 [2429][2429l]|[Minimize XOR][2429]                                                                  |![rs]
 [2432][2432l]|[The Employee That Worked on the Longest Task][2432]                                  |![rs]
 [2433][2433l]|[Find The Original Array of Prefix Xor][2433]                                         |![rs]
+[2434][2434l]|[Using a Robot to Print the Lexicographically Smallest String][2434]                  |![rs]
 [2437][2437l]|[Number of Valid Clock Times][2437]                                                   |![py]
 [2441][2441l]|[Largest Positive Integer That Exists With Its Negative][2441]                        |![rs]
 [2442][2442l]|[Count Number of Distinct Integers After Reverse Operations][2442]                    |![py]
@@ -2259,6 +2260,7 @@
 [2429]:Problemset/2429-Minimize%20XOR/README.md#2429-minimize-xor
 [2432]:Problemset/2432-The%20Employee%20That%20Worked%20on%20the%20Longest%20Task/README.md#2432-the-employee-that-worked-on-the-longest-task
 [2433]:Problemset/2433-Find%20The%20Original%20Array%20of%20Prefix%20Xor/README.md#2433-find-the-original-array-of-prefix-xor
+[2434]:Problemset/2434-Using%20a%20Robot%20to%20Print%20the%20Lexicographically%20Smallest%20String/README.md#2434-using-a-robot-to-print-the-lexicographically-smallest-string
 [2437]:Problemset/2437-Number%20of%20Valid%20Clock%20Times/README.md#2437-number-of-valid-clock-times
 [2441]:Problemset/2441-Largest%20Positive%20Integer%20That%20Exists%20With%20Its%20Negative/README.md#2441-largest-positive-integer-that-exists-with-its-negative
 [2442]:Problemset/2442-Count%20Number%20of%20Distinct%20Integers%20After%20Reverse%20Operations/README.md#2442-count-number-of-distinct-integers-after-reverse-operations
@@ -3414,6 +3416,7 @@
 [2429l]:https://leetcode.com/problems/minimize-xor/
 [2432l]:https://leetcode.com/problems/the-employee-that-worked-on-the-longest-task/
 [2433l]:https://leetcode.com/problems/find-the-original-array-of-prefix-xor/
+[2434l]:https://leetcode.com/problems/using-a-robot-to-print-the-lexicographically-smallest-string/
 [2437l]:https://leetcode.com/problems/number-of-valid-clock-times/
 [2441l]:https://leetcode.com/problems/largest-positive-integer-that-exists-with-its-negative/
 [2442l]:https://leetcode.com/problems/count-number-of-distinct-integers-after-reverse-operations/

README_CN.md

@@ -1109,6 +1109,7 @@
 [2429][2429l]|[最小 XOR][2429]                                          |![rs]
 [2432][2432l]|[处理用时最长的那个任务的员工][2432]                      |![rs]
 [2433][2433l]|[找出前缀异或的原始数组][2433]                            |![rs]
+[2434][2434l]|[使用机器人打印字典序最小的字符串][2434]                  |![rs]
 [2437][2437l]|[有效时间的数目][2437]                                    |![py]
 [2441][2441l]|[与对应负数同时存在的最大正整数][2441]                    |![rs]
 [2442][2442l]|[反转之后不同整数的数目][2442]                            |![py]
@@ -2259,6 +2260,7 @@
 [2429]:Problemset/2429-Minimize%20XOR/README_CN.md#2429-最小-xor
 [2432]:Problemset/2432-The%20Employee%20That%20Worked%20on%20the%20Longest%20Task/README_CN.md#2432-处理用时最长的那个任务的员工
 [2433]:Problemset/2433-Find%20The%20Original%20Array%20of%20Prefix%20Xor/README_CN.md#2433-找出前缀异或的原始数组
+[2434]:Problemset/2434-Using%20a%20Robot%20to%20Print%20the%20Lexicographically%20Smallest%20String/README_CN.md#2434-使用机器人打印字典序最小的字符串
 [2437]:Problemset/2437-Number%20of%20Valid%20Clock%20Times/README_CN.md#2437-有效时间的数目
 [2441]:Problemset/2441-Largest%20Positive%20Integer%20That%20Exists%20With%20Its%20Negative/README_CN.md#2441-与对应负数同时存在的最大正整数
 [2442]:Problemset/2442-Count%20Number%20of%20Distinct%20Integers%20After%20Reverse%20Operations/README_CN.md#2442-反转之后不同整数的数目
@@ -3414,6 +3416,7 @@
 [2429l]:https://leetcode.cn/problems/minimize-xor/
 [2432l]:https://leetcode.cn/problems/the-employee-that-worked-on-the-longest-task/
 [2433l]:https://leetcode.cn/problems/find-the-original-array-of-prefix-xor/
+[2434l]:https://leetcode.cn/problems/using-a-robot-to-print-the-lexicographically-smallest-string/
 [2437l]:https://leetcode.cn/problems/number-of-valid-clock-times/
 [2441l]:https://leetcode.cn/problems/largest-positive-integer-that-exists-with-its-negative/
 [2442l]:https://leetcode.cn/problems/count-number-of-distinct-integers-after-reverse-operations/