LC 1208. Get Equal Substrings Within Budget (Rust SW)

Author: raul-sauco

README.md

@@ -455,6 +455,7 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 | [1171. Remove Zero Sum Consecutive Nodes from Linked List][lc1171]                            | 🟠 Medium  | [![python](res/py.png)][lc1171py]                                                                     |
 | [1187. Make Array Strictly Increasing][lc1187]                                                | 🔴 Hard    | [![python](res/py.png)][lc1187py]                                                                     |
 | [1207. Unique Number of Occurrences][lc1207]                                                  | 🟢 Easy    | [![python](res/py.png)][lc1207py] [![rust](res/rs.png)][lc1207rs]                                     |
+| [1208. Get Equal Substrings Within Budget][lc1208]                                            | 🟠 Medium  | [![rust](res/rs.png)][lc1208rs]                                                                       |
 | [1219. Path with Maximum Gold][lec1219]                                                       | 🟠 Medium  | [![rust](res/rs.png)][lc1219rs]                                                                       |
 | [1220. Count Vowels Permutation][lc1220]                                                      | 🔴 Hard    | [![python](res/py.png)][lc1220py] [![rust](res/rs.png)][lc1220rs]                                     |
 | [1232. Check If It Is a Straight Line][lc1232]                                                | 🟢 Easy    | [![rust](res/rs.png)][lc1232rs]                                                                       |
@@ -1724,6 +1725,8 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 [lc1207]: https://leetcode.com/problems/unique-number-of-occurrences/
 [lc1207py]: leetcode/unique-number-of-occurrences.py
 [lc1207rs]: leetcode/unique-number-of-occurrences.rs
+[lc1208]: https://leetcode.com/problems/get-equal-substrings-within-budget/
+[lc1208rs]: leetcode/get-equal-substrings-within-budget.rs
 [lc1219]: https://leetcode.com/problems/path-with-maximum-gold/
 [lc1219rs]: leetcode/path-with-maximum-gold.rs
 [lc1220]: https://leetcode.com/problems/count-vowels-permutation/

leetcode/get-equal-substrings-within-budget.rs

@@ -0,0 +1,75 @@
+// 1208. Get Equal Substrings Within Budget
+// 🟠 Medium
+//
+// https://leetcode.com/problems/get-equal-substrings-within-budget/
+//
+// Tags: String - Binary Search - Sliding Window - Prefix Sum
+
+struct Solution;
+impl Solution {
+    /// Get a vector of the cost of converting each character, after that use a sliding window,
+    /// since we are looking for the largest window, we can only allow the window to grow, not
+    /// shrink, and only update the max length when the window does grow.
+    ///
+    /// Time complexity: O(n) - We visit each element and do constant time work, both constructing
+    /// the vector of sums and during the sliding window.
+    /// Space complexity: O(n) - The sums vector. Since in Rust we cannot access string characters
+    /// by index, I am not too sure how we could do it in O(1)
+    ///
+    /// Runtime 1 ms Beats 100%
+    /// Memory 2.64 MB Beats 44%
+    pub fn equal_substring(s: String, t: String, max_cost: i32) -> i32 {
+        let mut l = 0;
+        let sums = s
+            .bytes()
+            .zip(t.bytes())
+            .map(|(x, y)| (x as i32 - y as i32).abs())
+            .collect::<Vec<_>>();
+        let mut cost = 0;
+        let mut max_length = 0;
+        for r in 0..sums.len() {
+            cost += sums[r];
+            if cost > max_cost {
+                cost -= sums[l];
+                l += 1;
+            } else {
+                max_length = r - l + 1;
+            }
+        }
+        max_length as i32
+    }
+}
+
+// Tests.
+fn main() {
+    let tests = [
+        ("abcd", "bcdf", 3, 3),
+        ("abcd", "cdef", 3, 1),
+        ("abcd", "acde", 0, 1),
+    ];
+    println!("\n\x1b[92m» Running {} tests...\x1b[0m", tests.len());
+    let mut success = 0;
+    for (i, t) in tests.iter().enumerate() {
+        let res = Solution::equal_substring(t.0.to_string(), t.1.to_string(), t.2);
+        if res == t.3 {
+            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.3, 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
+        )
+    }
+}