Rust

Author: MaskRay

longest-happy-string.rs

@@ -0,0 +1,24 @@
+// Longest Happy String
+impl Solution {
+    pub fn longest_diverse_string(a: i32, b: i32, c: i32) -> String {
+        use std::mem::swap;
+        let mut ans = vec![];
+        let mut s = vec![a, b, c];
+        let mut l2 = 3;
+        let mut l1 = 3;
+        while s[0]+s[1]+s[2] > 0 {
+            let mut x = 0; let mut y = 1; let mut z = 2;
+            if s[x] < s[y] { swap(&mut x, &mut y); }
+            if s[y] < s[z] { swap(&mut y, &mut z); }
+            if s[x] < s[y] { swap(&mut x, &mut y); }
+            if x != l2 || x != l1 {}
+            else if s[y] > 0 { x = y; }
+            else { break; }
+            ans.push(b'a'+x as u8);
+            s[x] -= 1;
+            l2 = l1;
+            l1 = x;
+        }
+        String::from_utf8_lossy(&ans).into_owned()
+    }
+}

minimum-add-to-make-parentheses-valid.rs

@@ -0,0 +1,17 @@
+// Minimum Add to Make Parentheses Valid
+impl Solution {
+    pub fn min_add_to_make_valid(s: String) -> i32 {
+        let mut l = 0;
+        let mut r = 0;
+        for &c in s.as_bytes().iter() {
+            if c == b'(' {
+                l += 1;
+            } else if l > 0 {
+                l -= 1;
+            } else {
+                r += 1;
+            }
+        }
+        l+r
+    }
+}

minimum-insertions-to-balance-a-parentheses-string.rs

@@ -0,0 +1,23 @@
+// Minimum Insertions to Balance a Parentheses String
+impl Solution {
+    pub fn min_insertions(s: String) -> i32 {
+        let mut ans = 0;
+        let mut x = 0;
+        for &c in s.as_bytes().iter() {
+            if c == b'(' {
+                if x%2 == 1 {
+                    x -= 1;
+                    ans += 1;
+                }
+                x += 2;
+            } else {
+                if x == 0 {
+                    x += 2;
+                    ans += 1;
+                }
+                x -= 1;
+            }
+        }
+        ans+x
+    }
+}

minimum-number-of-swaps-to-make-the-string-balanced.rs

@@ -0,0 +1,14 @@
+// Minimum Number of Swaps to Make the String Balanced
+impl Solution {
+    pub fn min_swaps(s: String) -> i32 {
+        let mut x = 0;
+        for &c in s.as_bytes().iter() {
+            if c == b'[' {
+                x += 1;
+            } else if x > 0 {
+                x -= 1;
+            }
+        }
+        (x+1)/2
+    }
+}

remove-invalid-parentheses.rs

@@ -0,0 +1,31 @@
+impl Solution {
+    pub fn remove_invalid_parentheses(s: String) -> Vec<String> {
+        fn dfs(s: Vec<u8>, ans: &mut Vec<String>, par: u8, ii: usize, jj: usize) {
+            let mut c = 0i32;
+            for i in ii..s.len() {
+                if s[i] == par { c += 1; }
+                else if s[i] == (par^1) { c -= 1; }
+                if c < 0 {
+                    for j in jj..=i {
+                        if s[j] == (par^1) && (j == jj || s[j-1] != (par^1)) {
+                            let mut s1 = s.clone();
+                            s1.remove(j);
+                            dfs(s1, ans, par, i, j);
+                        }
+                    }
+                    return;
+                }
+            }
+            let mut s1 = s.clone();
+            s1.reverse();
+            if par == b'(' {
+                dfs(s1, ans, par^1, 0, 0);
+            } else {
+                ans.push(String::from_utf8_lossy(&s1).into_owned());
+            }
+        }
+        let mut ans = vec![];
+        dfs(Vec::from(s.as_bytes()), &mut ans, b'(', 0, 0);
+        ans
+    }
+}

valid-parenthesis-string.rs

@@ -0,0 +1,22 @@
+// Valid Parenthesis String
+impl Solution {
+    pub fn check_valid_string(s: String) -> bool {
+        let mut mn = 0i32;
+        let mut mx = 0i32;
+        for &c in s.as_bytes().iter() {
+            if c == b'(' {
+                mn += 1;
+                mx += 1;
+            } else if c == b')' {
+                mn -= 1;
+                mx -= 1;
+            } else {
+                mn -= 1;
+                mx += 1;
+            }
+            if mx < 0 { return false; }
+            mn = mn.max(0);
+        }
+        mn == 0
+    }
+}