A few simple solutions

Author: leopsidom

1189.maximum-number-of-balloons.rs

@@ -0,0 +1,45 @@
+/*
+ * @lc app=leetcode id=1189 lang=rust
+ *
+ * [1189] Maximum Number of Balloons
+ */
+
+// @lc code=start
+use std::collections::HashMap;
+use std::cmp;
+
+impl Solution {
+    pub fn max_number_of_balloons(text: String) -> i32 {
+        let mut ballon_count = HashMap::new();
+        for ch in "balon".chars() {
+            ballon_count.insert(ch, 0);
+        }
+
+        for ch in text.chars() {
+            match ballon_count.get_mut(&ch) {
+                Some(val) => *val += 1,
+                None => ()
+            }
+        }
+
+        let mut ans = text.len();
+
+        for ch in "balon".chars() {
+
+            let cnt = *ballon_count.get(&ch).unwrap();
+            match ch {
+                'l' | 'o' => {
+                    ans = cmp::min(ans, cnt / 2);
+                },
+                'b' | 'a' | 'n' => {
+                    ans = cmp::min(ans, cnt);
+                },
+                _ => ()
+            }
+        }
+        
+        ans as i32
+    }
+}
+// @lc code=end
+

1200.minimum-absolute-difference.rs

@@ -0,0 +1,30 @@
+/*
+ * @lc app=leetcode id=1200 lang=rust
+ *
+ * [1200] Minimum Absolute Difference
+ */
+
+// @lc code=start
+use std::collections::HashMap;
+use std::i32;
+
+impl Solution {
+    pub fn minimum_abs_difference(mut arr: Vec<i32>) -> Vec<Vec<i32>> {
+        let mut diff_map = HashMap::new();
+        let mut min_diff = i32::MAX;
+        arr.sort();
+
+        for i in 0..arr.len()-1 {
+            let d = arr[i+1] - arr[i];
+            if d < min_diff { min_diff = d; }
+            diff_map.entry(d).or_insert(vec![]).push(vec![arr[i], arr[i+1]]);
+        }
+
+        match diff_map.get(&min_diff) {
+            Some(v) => v.clone(),
+            None => vec![]
+        }
+    }
+}
+// @lc code=end
+

1207.unique-number-of-occurrences.rs

@@ -0,0 +1,23 @@
+/*
+ * @lc app=leetcode id=1207 lang=rust
+ *
+ * [1207] Unique Number of Occurrences
+ */
+
+// @lc code=start
+use std::collections::HashMap;
+use std::collections::HashSet;
+
+impl Solution {
+    pub fn unique_occurrences(arr: Vec<i32>) -> bool {
+        let mut counter = HashMap::new();
+
+        for ele in arr {
+            *counter.entry(ele).or_insert(0) += 1;
+        }
+
+        counter.values().collect::<HashSet<_>>().len() == counter.len()
+    }
+}
+// @lc code=end
+

1221.split-a-string-in-balanced-strings.rs

@@ -0,0 +1,29 @@
+/*
+ * @lc app=leetcode id=1221 lang=rust
+ *
+ * [1221] Split a String in Balanced Strings
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn balanced_string_split(s: String) -> i32 {
+        let mut balance = 0;
+        let mut res = 0;
+
+        for c in s.chars() {
+            match c {
+                'L' => balance += 1,
+                'R' => balance -= 1,
+                _ => panic!("Unexpected character found")
+            }
+
+            if balance == 0 {
+                res += 1;
+            }
+        }
+
+        res
+    }
+}
+// @lc code=end
+

1232.check-if-it-is-a-straight-line.rs

@@ -0,0 +1,34 @@
+/*
+ * @lc app=leetcode id=1232 lang=rust
+ *
+ * [1232] Check If It Is a Straight Line
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn check_straight_line(coordinates: Vec<Vec<i32>>) -> bool {
+        if (coordinates.len() <= 2) {
+            return true;
+        }
+        
+        let N = coordinates.len();
+        
+        let p1 = &coordinates[0];
+        let p2 = &coordinates[1];
+        
+        for i in 2..N {
+            let p3 = &coordinates[i];
+            if !Self::same_line_with(p1, p2, p3) {
+                return false;
+            }
+        }
+        
+        return true;
+    }
+
+    pub fn same_line_with(p1: &Vec<i32>, p2: &Vec<i32>, p3: &Vec<i32>) -> bool {
+        (p2[1] - p1[1]) * (p3[0] - p1[0]) == (p3[1] - p1[1]) * (p2[0] - p1[0])
+    }
+}
+// @lc code=end
+

227.basic-calculator-ii.rs

@@ -0,0 +1,68 @@
+/*
+ * @lc app=leetcode id=227 lang=rust
+ *
+ * [227] Basic Calculator II
+ */
+
+// @lc code=start
+use std::collections::HashSet;
+
+impl Solution {
+    pub fn calculate(mut s: String) -> i32 {
+        let mut digits = vec![];
+        let mut ops = vec![];
+
+        let mut curr = 0;
+        s.push('*');
+
+        for ch in s.chars() {
+            if ch.is_ascii_digit() {
+                curr *= 10;
+                curr += ch.to_digit(10).unwrap_or_default() as i32;
+            } else if ch != ' ' {
+                match ops.pop() {
+                    Some('*') => {
+                        let prev = digits.pop().unwrap();
+                        digits.push(prev * curr);
+                    },
+                    Some('/') => {
+                        let prev = digits.pop().unwrap();
+                        digits.push(prev / curr);
+                    },
+                    Some(op) => {
+                        digits.push(curr);
+                        ops.push(op);
+                    },
+                    None => {
+                        digits.push(curr);
+                    }
+                }
+
+                ops.push(ch);
+                curr = 0;
+            }
+        }
+
+        ops.pop();
+
+        // println!("digits: {:?}, ops: {:?}, curr: {}", digits, ops, curr);
+
+        let mut ans = *digits.first().unwrap_or(&0);
+
+        for i in 0..digits.len()-1 {
+            match ops[i] {
+                '+' => {
+                    ans += digits[i+1];
+                },
+                '-' => {
+                    ans -= digits[i+1];
+                },
+                _ => {}
+            }
+        }
+
+        ans
+    }
+}
+// @lc code=end
+

230.kth-smallest-element-in-a-bst.rs

@@ -0,0 +1,58 @@
+/*
+ * @lc app=leetcode id=230 lang=rust
+ *
+ * [230] Kth Smallest Element in a BST
+ */
+
+// @lc code=start
+// Definition for a binary tree node.
+// #[derive(Debug, PartialEq, Eq)]
+// pub struct TreeNode {
+//   pub val: i32,
+//   pub left: Option<Rc<RefCell<TreeNode>>>,
+//   pub right: Option<Rc<RefCell<TreeNode>>>,
+// }
+// 
+// impl TreeNode {
+//   #[inline]
+//   pub fn new(val: i32) -> Self {
+//     TreeNode {
+//       val,
+//       left: None,
+//       right: None
+//     }
+//   }
+// }
+use std::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    pub fn kth_smallest(mut root: Option<Rc<RefCell<TreeNode>>>, k: i32) -> i32 {
+        if root.is_none() { return 0; }
+        let mut nodes = vec![];
+
+        while let Some(rc_node) = root {
+            nodes.push(Some(rc_node.clone()));
+            root = rc_node.borrow().left.clone();
+        }
+        
+        let mut i = 0;
+        loop {
+            root = nodes.pop().unwrap();
+            i += 1;
+            if i == k {
+                let val = root.unwrap().borrow().val;
+                return val;
+            }
+
+            root = root.unwrap().borrow().right.clone();
+            while let Some(rc_node) = root {
+                nodes.push(Some(rc_node.clone()));
+                root = rc_node.borrow().left.clone();
+            }
+        }
+
+        return 0;
+    }
+}
+// @lc code=end
+