Ran Rust Format

Author: ryanoneill

src/average_salary_excluding_the_minimum_and_maximum_salary.rs

@@ -9,7 +9,6 @@ use std::cmp::min;
 struct Solution;
 
 impl Solution {
-
     pub fn average(salary: Vec<i32>) -> f64 {
         let n = salary.len();
         let mut min_salary = i32::max_value();
@@ -26,7 +25,6 @@ impl Solution {
         sum -= max_salary;
         sum as f64 / (n - 2) as f64
     }
-
 }
 
 #[cfg(test)]
@@ -46,5 +44,4 @@ mod tests {
         let result = Solution::average(salary);
         assert_eq!(result, 2000.00000);
     }
-
 }

src/best_time_to_buy_and_sell_stock.rs

@@ -12,7 +12,6 @@ use std::cmp::min;
 struct Solution;
 
 impl Solution {
-
     pub fn max_profit(prices: Vec<i32>) -> i32 {
         let n = prices.len();
         let mut profit = 0;
@@ -25,7 +24,6 @@ impl Solution {
 
         profit
     }
-
 }
 
 #[cfg(test)]
@@ -34,16 +32,15 @@ mod tests {
 
     #[test]
     fn example_1() {
-        let prices = vec![7,1,5,3,6,4];
+        let prices = vec![7, 1, 5, 3, 6, 4];
         let result = Solution::max_profit(prices);
         assert_eq!(result, 5);
     }
 
     #[test]
     fn example_2() {
-        let prices = vec![7,6,4,3,1];
+        let prices = vec![7, 6, 4, 3, 1];
         let result = Solution::max_profit(prices);
         assert_eq!(result, 0);
     }
-
 }

src/climbing_stairs.rs

@@ -7,7 +7,6 @@ use std::collections::HashMap;
 struct Solution;
 
 impl Solution {
-
     pub fn climb_stairs(n: i32) -> i32 {
         let mut ways = HashMap::new();
         Self::worker(n, &mut ways)
@@ -22,15 +21,13 @@ impl Solution {
                 if ways.contains_key(&n) {
                     ways[&n]
                 } else {
-                    let result = Self::worker(n-1, ways) + Self::worker(n-2, ways);
+                    let result = Self::worker(n - 1, ways) + Self::worker(n - 2, ways);
                     ways.insert(n, result);
                     result
                 }
             }
-
         }
     }
-
 }
 
 #[cfg(test)]
@@ -50,5 +47,4 @@ mod tests {
         let result = Solution::climb_stairs(n);
         assert_eq!(result, 3);
     }
-
 }

src/coin_change.rs

@@ -12,32 +12,36 @@ use std::collections::HashMap;
 struct Solution;
 
 impl Solution {
-
     pub fn coin_change(coins: Vec<i32>, amount: i32) -> i32 {
         let mut mins = HashMap::new();
         Self::worker(&coins, amount, &mut mins)
     }
 
     fn worker(coins: &Vec<i32>, amount: i32, mins: &mut HashMap<i32, i32>) -> i32 {
-        if amount < 0 { -1 }
-        else if amount == 0 { 0 }
-        else if mins.contains_key(&amount) { mins[&amount] }
-        else {
+        if amount < 0 {
+            -1
+        } else if amount == 0 {
+            0
+        } else if mins.contains_key(&amount) {
+            mins[&amount]
+        } else {
             let mut result = -1;
             for coin in coins {
                 let sub = Self::worker(coins, amount - coin, mins);
                 if sub != -1 {
                     let current = sub + 1;
-                    if result == -1 { result = current; }
-                    else { result = min(result, current); }
+                    if result == -1 {
+                        result = current;
+                    } else {
+                        result = min(result, current);
+                    }
                 }
             }
 
             mins.insert(amount, result);
             result
         }
     }
-
 }
 
 #[cfg(test)]
@@ -46,7 +50,7 @@ mod tests {
 
     #[test]
     fn example_1() {
-        let coins = vec![1,2,5];
+        let coins = vec![1, 2, 5];
         let amount = 11;
         let result = Solution::coin_change(coins, amount);
         assert_eq!(result, 3);
@@ -67,5 +71,4 @@ mod tests {
         let result = Solution::coin_change(coins, amount);
         assert_eq!(result, 0);
     }
-
 }

src/container_with_most_water.rs

@@ -13,7 +13,6 @@ use std::cmp::max;
 struct Solution;
 
 impl Solution {
-
     pub fn max_area(height: Vec<i32>) -> i32 {
         let n = height.len();
         let mut max_area = 0;
@@ -37,7 +36,6 @@ impl Solution {
 
         max_area
     }
-
 }
 
 #[cfg(test)]
@@ -46,16 +44,15 @@ mod tests {
 
     #[test]
     fn example_1() {
-        let height = vec![1,8,6,2,5,4,8,3,7];
+        let height = vec![1, 8, 6, 2, 5, 4, 8, 3, 7];
         let result = Solution::max_area(height);
         assert_eq!(result, 49);
     }
 
     #[test]
     fn example_2() {
-        let height = vec![1,1];
+        let height = vec![1, 1];
         let result = Solution::max_area(height);
         assert_eq!(result, 1);
     }
-
 }

src/contains_duplicate.rs

@@ -6,7 +6,6 @@ use std::collections::HashSet;
 struct Solution;
 
 impl Solution {
-
     pub fn contains_duplicate(nums: Vec<i32>) -> bool {
         let mut seen = HashSet::new();
         let mut result = false;
@@ -20,7 +19,6 @@ impl Solution {
 
         result
     }
-
 }
 
 #[cfg(test)]
@@ -29,23 +27,22 @@ mod tests {
 
     #[test]
     fn example_1() {
-        let nums = vec![1,2,3,1];
+        let nums = vec![1, 2, 3, 1];
         let result = Solution::contains_duplicate(nums);
         assert!(result);
     }
 
     #[test]
     fn example_2() {
-        let nums = vec![1,2,3,4];
+        let nums = vec![1, 2, 3, 4];
         let result = Solution::contains_duplicate(nums);
         assert!(!result);
     }
 
     #[test]
     fn example_3() {
-        let nums = vec![1,1,1,3,3,4,3,2,4,2];
+        let nums = vec![1, 1, 1, 3, 3, 4, 3, 2, 4, 2];
         let result = Solution::contains_duplicate(nums);
         assert!(result);
     }
-
 }

src/destroying_asteroids.rs

@@ -11,7 +11,6 @@
 struct Solution;
 
 impl Solution {
-
     pub fn asteroids_destroyed(mass: i32, asteroids: Vec<i32>) -> bool {
         let mut mass = mass as i64;
         let mut by_smallest = asteroids;
@@ -30,7 +29,6 @@ impl Solution {
 
         result
     }
-
 }
 
 #[cfg(test)]
@@ -40,17 +38,16 @@ mod tests {
     #[test]
     fn example_1() {
         let mass = 10;
-        let asteroids = vec![3,9,19,5,21];
+        let asteroids = vec![3, 9, 19, 5, 21];
         let result = Solution::asteroids_destroyed(mass, asteroids);
         assert!(result);
     }
 
     #[test]
     fn example_2() {
         let mass = 5;
-        let asteroids = vec![4,9,23,4];
+        let asteroids = vec![4, 9, 23, 4];
         let result = Solution::asteroids_destroyed(mass, asteroids);
         assert!(!result);
     }
-
 }

src/find_k_closest_elements.rs

@@ -4,16 +4,14 @@ use std::collections::BinaryHeap;
 #[derive(Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 struct State {
     distance: usize,
-    num: i32
+    num: i32,
 }
 
 impl State {
-
     fn new(num: i32, x: i32) -> Self {
         let distance = i32::abs(num - x) as usize;
         State { distance, num }
     }
-
 }
 
 /// Given a sorted integer array `arr`, two integers `k` and `x`, return the
@@ -26,7 +24,6 @@ impl State {
 struct Solution;
 
 impl Solution {
-
     pub fn find_closest_elements(arr: Vec<i32>, k: i32, x: i32) -> Vec<i32> {
         let mut min_heap = BinaryHeap::new();
         for num in arr {
@@ -41,7 +38,6 @@ impl Solution {
         result.sort();
         result
     }
-
 }
 
 #[cfg(test)]
@@ -50,20 +46,19 @@ mod tests {
 
     #[test]
     fn example_1() {
-        let arr = vec![1,2,3,4,5];
+        let arr = vec![1, 2, 3, 4, 5];
         let k = 4;
         let x = 3;
         let result = Solution::find_closest_elements(arr, k, x);
-        assert_eq!(result, vec![1,2,3,4]);
+        assert_eq!(result, vec![1, 2, 3, 4]);
     }
 
     #[test]
     fn example_2() {
-        let arr = vec![1,2,3,4,5];
+        let arr = vec![1, 2, 3, 4, 5];
         let k = 4;
         let x = -1;
         let result = Solution::find_closest_elements(arr, k, x);
-        assert_eq!(result, vec![1,2,3,4]);
+        assert_eq!(result, vec![1, 2, 3, 4]);
     }
-
 }

src/find_median_from_data_stream.rs

@@ -1,4 +1,4 @@
-use std::{collections::BinaryHeap, cmp::Reverse};
+use std::{cmp::Reverse, collections::BinaryHeap};
 
 /// The median is the middle value in an ordered integer list. If the size of
 /// the list is even, there is no middle value, and the median is the mean of
@@ -19,15 +19,14 @@ use std::{collections::BinaryHeap, cmp::Reverse};
 ///   within `10^-5` of the actual answer will be accepted.
 struct MedianFinder {
     min_heap: BinaryHeap<Reverse<i32>>,
-    max_heap: BinaryHeap<i32>
+    max_heap: BinaryHeap<i32>,
 }
 
 impl MedianFinder {
-
     fn new() -> Self {
         Self {
             min_heap: BinaryHeap::new(),
-            max_heap: BinaryHeap::new()
+            max_heap: BinaryHeap::new(),
         }
     }
 
@@ -49,7 +48,9 @@ impl MedianFinder {
         let value = self.min_heap.peek();
         if value.is_some() {
             value.unwrap().0
-        } else { 0 }
+        } else {
+            0
+        }
     }
 
     fn find_median(&self) -> f64 {
@@ -61,8 +62,6 @@ impl MedianFinder {
         }
         result
     }
-
-
 }
 
 #[cfg(test)]
@@ -80,5 +79,4 @@ mod tests {
         let result2 = median_finder.find_median();
         assert_eq!(result2, 2.0);
     }
-
 }