.

Author: guangsheng.li01

src/a0726_number_of_atoms.rs

@@ -0,0 +1,91 @@
+/*
+ * [0726] number-of-atoms
+ */
+
+struct Solution;
+
+use std::collections::HashMap;
+impl Solution {
+    pub fn count_of_atoms(formula: String) -> String {
+        let bytes = formula.as_bytes();
+        let mut stack: Vec<HashMap<String, i32>> = Vec::new();
+        let mut i = 0;
+        let n = formula.len();
+        stack.push(HashMap::new());
+        while i < n {
+            let c = bytes[i] as char;
+            if c == '(' {
+                stack.push(HashMap::new());
+                i += 1;
+            } else if c == ')' {
+                let top = stack.pop().unwrap();
+                i += 1;
+                let start = i;
+                while i < n && bytes[i].is_ascii_digit() {
+                    i += 1;
+                }
+                let number = Self::toi32(&bytes[start..i]);
+                let m: &mut HashMap<String, i32> = stack.last_mut().unwrap();
+                for (name, count) in top {
+                    *m.entry(name).or_insert(0) += count * number;
+                }
+            } else {
+                // parse atom name
+                let start = i + 1;
+                i += 1;
+                while i < n && bytes[i].is_ascii_lowercase() {
+                    i += 1;
+                }
+                let name = Self::to_string(&bytes[start - 1..i]);
+
+                // parse atom count
+                let start = i;
+                while i < n && bytes[i].is_ascii_digit() {
+                    i += 1;
+                }
+                let count = Self::toi32(&bytes[start..i]);
+                let m: &mut HashMap<String, i32> = stack.last_mut().unwrap();
+                *m.entry(name).or_insert(0) += count;
+            }
+        }
+
+        let map = stack.last().unwrap();
+        let mut v: Vec<_> = map.into_iter().collect();
+        v.sort_by(|x, y| x.0.cmp(&y.0));
+
+        let mut res = "".to_string();
+        for (name, count) in v {
+            res.push_str(name);
+            if *count > 1 {
+                res.push_str(&count.to_string());
+            }
+        }
+        res.to_owned()
+    }
+
+    fn toi32(v: &[u8]) -> i32 {
+        if v.len() == 0 {
+            return 1;
+        }
+        std::str::FromStr::from_str(std::str::from_utf8(v).unwrap()).unwrap()
+    }
+
+    fn to_string(v: &[u8]) -> String {
+        std::str::from_utf8(v).unwrap().to_string()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_case0() {
+        assert_eq!(Solution::count_of_atoms("H2O".to_owned()), "H2O");
+        assert_eq!(Solution::count_of_atoms("Mg(OH)2".to_owned()), "H2MgO2");
+        assert_eq!(
+            Solution::count_of_atoms("K4(ON(SO3)2)2".to_owned()),
+            "K4N2O14S4"
+        );
+    }
+}

src/a0783_minimum_distance_between_bst_nodes.rs

@@ -0,0 +1,43 @@
+/*
+ * [0783] minimum-distance-between-bst-nodes
+ */
+
+use super::utils::tree::*;
+struct Solution;
+
+use std::cell::RefCell;
+use std::i32::{MAX, MIN};
+use std::rc::Rc;
+impl Solution {
+    pub fn min_diff_in_bst(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
+        let mut diff = MAX;
+        let mut pval = MIN;
+        Self::dfs(root, &mut pval, &mut diff);
+        diff
+    }
+
+    fn dfs(root: Option<Rc<RefCell<TreeNode>>>, pval: &mut i32, diff: &mut i32) {
+        if let Some(root) = root {
+            let root = root.borrow();
+            Self::dfs(root.left.clone(), pval, diff);
+            if *pval > MIN {
+                *diff = std::cmp::min(*diff, root.val - *pval);
+            }
+            *pval = root.val;
+            Self::dfs(root.right.clone(), pval, diff);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_case0() {
+        assert_eq!(
+            Solution::min_diff_in_bst(tree![4, 2, 6, 1, 3, null, null]),
+            1
+        );
+    }
+}

src/casting_between_types.rs

@@ -0,0 +1,18 @@
+fn u8_slice_to_i32(v: &[u8]) -> i32 {
+    std::str::FromStr::from_str(std::str::from_utf8(v).unwrap()).unwrap()
+}
+
+fn u8_slice_to_string() {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_u8_slice_to_i32() {
+        let s = String::from("123456");
+        let bytes = s.as_bytes();
+        let u8_slice = &bytes[1..5];
+        assert_eq!(u8_slice_to_i32(u8_slice), 2345i32);
+    }
+}

src/lib.rs

@@ -34,7 +34,9 @@ mod a0643_maximum_average_subarray_i;
 mod a0646_maximum_length_of_pair_chain;
 mod a0654_maximum_binary_tree;
 mod a0701_insert_into_a_binary_search_tree;
+mod a0726_number_of_atoms;
 mod a0761_special_binary_string;
+mod a0783_minimum_distance_between_bst_nodes;
 mod a0867_transpose_matrix;
 mod a0883_projection_area_of_3d_shapes;
 mod a0894_all_possible_full_binary_trees;
@@ -54,3 +56,4 @@ mod a1287_element_appearing_more_than_25_in_sorted_array;
 mod a1302_deepest_leaves_sum;
 mod a1315_sum_of_nodes_with_even_valued_grandparent;
 mod a1317_convert_integer_to_the_sum_of_two_no_zero_integers;
+mod casting_between_types;