leetcode practice easy exercise

Author: eamondang

.gitignore

@@ -0,0 +1,2 @@
+/target
+/Cargo.lock

Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "leetcode-solving"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

src/easy/e1342_number_of_steps.rs

@@ -0,0 +1,38 @@
+#![allow(dead_code)]
+struct Solution;
+
+impl Solution {
+    pub fn number_of_steps(mut n: i32) -> i32 {
+        let mut steps = 0;
+        while n > 0 {
+            if n % 2 == 0 {
+                steps += 1;
+                n /= 2;
+            } else {
+                steps += 1;
+                n -= 1;
+            }
+        }
+        steps
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn steps_of_14() {
+        assert_eq!(Solution::number_of_steps(14), 6);
+    }
+
+    #[test]
+    fn steps_of_8() {
+        assert_eq!(Solution::number_of_steps(8), 4);
+    }
+
+    #[test]
+    fn steps_of_100() {
+        assert_eq!(Solution::number_of_steps(100), 9);
+    }
+}

src/easy/e1480_running_sum_of_1d_array.rs

@@ -0,0 +1,36 @@
+#![allow(dead_code)]
+struct Solution;
+
+impl Solution {
+    pub fn running_sum(nums: Vec<i32>) -> Vec<i32> {
+        nums.iter()
+            .scan(0, |prev, curr| {
+                *prev += curr;
+                Some(*prev)
+            })
+            .collect()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn case_1() {
+        let nums = vec![1, 2, 3, 4];
+        assert_eq!(Solution::running_sum(nums), vec![1, 3, 6, 10]);
+    }
+
+    #[test]
+    fn case_2() {
+        let nums = vec![1, 1, 1, 1, 1];
+        assert_eq!(Solution::running_sum(nums), vec![1, 2, 3, 4, 5]);
+    }
+
+    #[test]
+    fn case_3() {
+        let nums = vec![3, 1, 2, 10, 1];
+        assert_eq!(Solution::running_sum(nums), vec![3, 4, 6, 16, 17]);
+    }
+}

src/easy/e1672_richest_customer_wealth.rs

@@ -0,0 +1,31 @@
+#![allow(dead_code)]
+struct Solution;
+
+impl Solution {
+    pub fn maximun_wealth(accounts: Vec<Vec<i32>>) -> i32 {
+        accounts.iter().map(|i| i.iter().sum()).max().unwrap()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn array_2d() {
+        let accounts = vec![vec![1, 2, 3], vec![3, 2, 1]];
+        assert_eq!(Solution::maximun_wealth(accounts), 6);
+    }
+
+    #[test]
+    fn array_3x2() {
+        let accounts = vec![vec![1, 5], vec![7, 3], vec![3, 5]];
+        assert_eq!(Solution::maximun_wealth(accounts), 10);
+    }
+
+    #[test]
+    fn array_3x3() {
+        let accounts = vec![vec![2, 8, 7], vec![7, 1, 3], vec![1, 9, 5]];
+        assert_eq!(Solution::maximun_wealth(accounts), 17);
+    }
+}

src/easy/e412_fizz_buzz.rs

@@ -0,0 +1,43 @@
+#![allow(dead_code)]
+struct Solution;
+
+impl Solution {
+    pub fn fizz_buzz(n: i32) -> Vec<String> {
+        let mut result: Vec<String> = vec![];
+        for i in 1..=n {
+            match (i % 3, i % 5) {
+                (0, 0) => result.push("FizzBuzz".into()),
+                (0, _) => result.push("Fizz".into()),
+                (_, 0) => result.push("Buzz".into()),
+                _ => result.push(i.to_string()),
+            };
+        }
+        result
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn elements_3() {
+        assert_eq!(Solution::fizz_buzz(3), vec!["1", "2", "Fizz"]);
+    }
+
+    #[test]
+    fn element_5() {
+        assert_eq!(Solution::fizz_buzz(5), vec!["1", "2", "Fizz", "4", "Buzz"]);
+    }
+
+    #[test]
+    fn element_15() {
+        assert_eq!(
+            Solution::fizz_buzz(15),
+            vec![
+                "1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz",
+                "13", "14", "FizzBuzz"
+            ]
+        );
+    }
+}

src/easy/mod.rs

@@ -0,0 +1,4 @@
+mod e1342_number_of_steps;
+mod e1480_running_sum_of_1d_array;
+mod e1672_richest_customer_wealth;
+mod e412_fizz_buzz;

src/lib.rs

@@ -0,0 +1 @@
+pub mod easy;