LC 2938. Separate Black and White Balls (Rust)

Author: raul-sauco

README.md

@@ -758,6 +758,7 @@ to the solution in this repository.
 | [2849. Determine if a Cell Is Reachable at a Given Time][lc2849]                              | 🟠 Medium  | [![rust](res/rs.png)][lc2849rs]                                                                       |
 | [2864. Maximum Odd Binary Number][lc2864]                                                     | 🟢 Easy    | [![rust](res/rs.png)][lc2864rs]                                                                       |
 | [2870. Minimum Number of Operations to Make Array Empty][lc2870]                              | 🟠 Medium  | [![rust](res/rs.png)][lc2870rs]                                                                       |
+| [2938. Separate Black and White Balls][lc2938]                                                | 🟠 Medium  | [![rust](res/rs.png)][lc2938rs]                                                                       |
 | [2958. Length of Longest Subarray With at Most K Frequency][lc2958]                           | 🟠 Medium  | [![rust](res/rs.png)][lc2958rs]                                                                       |
 | [2962. Count Subarrays Where Max Element Appears at Least K Times][lc2962]                    | 🟠 Medium  | [![rust](res/rs.png)][lc2962rs]                                                                       |
 | [2966. Divide Array Into Arrays With Max Difference][lc2966]                                  | 🟠 Medium  | [![rust](res/rs.png)][lc2966rs]                                                                       |
@@ -2438,6 +2439,8 @@ to the solution in this repository.
 [lc2864rs]: leetcode/maximum-odd-binary-number.rs
 [lc2870]: https://leetcode.com/problems/minimum-number-of-operations-to-make-array-empty/
 [lc2870rs]: leetcode/minimum-number-of-operations-to-make-array-empty.rs
+[lc2938]: https://leetcode.com/problems/separate-black-and-white-balls/
+[lc2938rs]: leetcode/separate-black-and-white-balls.rs
 [lc2958]: https://leetcode.com/problems/length-of-longest-subarray-with-at-most-k-frequency/
 [lc2958rs]: leetcode/length-of-longest-subarray-with-at-most-k-frequency.rs
 [lc2962]: https://leetcode.com/problems/count-subarrays-where-max-element-appears-at-least-k-times/

leetcode/separate-black-and-white-balls.rs

@@ -0,0 +1,81 @@
+// 2938. Separate Black and White Balls
+// 🟠 Medium
+//
+// https://leetcode.com/problems/separate-black-and-white-balls/
+//
+// Tags: Two Pointers - String - Greedy
+
+struct Solution;
+impl Solution {
+    /// Iterate the string from the left keeping track of where the last white ball in placed, for
+    /// each white ball found, move it to the furthest left spot possible and increment the index
+    /// of the next white ball, add the number of moves done to the result. Once you have placed
+    /// all the white balls on the left, all the black ones will be on the right.
+    ///
+    /// Time complexity: O(n) - O(1) work for each element in the input.
+    /// Space complexity: O(1)
+    ///
+    /// Runtime 0 ms Beats 100%
+    /// Memory 2.43 MB Beats 40%
+    #[allow(dead_code)]
+    pub fn minimum_steps_loop(s: String) -> i64 {
+        let (mut res, mut next_white_idx) = (0, 0);
+        for (i, b) in s.bytes().enumerate() {
+            if b == b'0' {
+                res += (i - next_white_idx) as i64;
+                next_white_idx += 1;
+            }
+        }
+        res
+    }
+
+    /// Same logic but using an iterator.
+    ///
+    /// Time complexity: O(n) - O(1) work for each element in the input.
+    /// Space complexity: O(1)
+    ///
+    /// Runtime 0 ms Beats 100%
+    /// Memory 2.34 MB Beats 100%
+    pub fn minimum_steps(s: String) -> i64 {
+        s.bytes()
+            .enumerate()
+            .fold((0, 0), |(res, idx), (i, b)| {
+                if b == b'0' {
+                    (res + (i - idx) as i64, idx + 1)
+                } else {
+                    (res, idx)
+                }
+            })
+            .0
+    }
+}
+
+// Tests.
+fn main() {
+    let tests = [("101", 1), ("100", 2), ("0111", 0), ("0011000010", 11)];
+    println!("\n\x1b[92m» Running {} tests...\x1b[0m", tests.len());
+    let mut success = 0;
+    for (i, t) in tests.iter().enumerate() {
+        let res = Solution::minimum_steps(t.0.to_string());
+        if res == t.1 {
+            success += 1;
+            println!("\x1b[92m✔\x1b[95m Test {} passed!\x1b[0m", i);
+        } else {
+            println!(
+                "\x1b[31mx\x1b[95m Test {} failed expected: {:?} but got {}!!\x1b[0m",
+                i, t.1, res
+            );
+        }
+    }
+    println!();
+    if success == tests.len() {
+        println!("\x1b[30;42m✔ All tests passed!\x1b[0m")
+    } else if success == 0 {
+        println!("\x1b[31mx \x1b[41;37mAll tests failed!\x1b[0m")
+    } else {
+        println!(
+            "\x1b[31mx\x1b[95m {} tests failed!\x1b[0m",
+            tests.len() - success
+        )
+    }
+}