run formatter

Author: mflinn-broad

src/days/day1.rs

@@ -1,16 +1,17 @@
 use crate::util;
 
 fn process_input(input: String) -> Vec<i64> {
-    input.split_whitespace()
+    input
+        .split_whitespace()
         .map(|num| num.parse().unwrap())
         .collect()
 }
 
-fn part_1 (data: &Vec<i64>) -> usize {
+fn part_1(data: &Vec<i64>) -> usize {
     get_num_increasing_windows(2, data)
 }
 
-fn part_2 (data: &Vec<i64>) -> usize {
+fn part_2(data: &Vec<i64>) -> usize {
     get_num_increasing_windows(4, data)
 }
 
@@ -29,25 +30,21 @@ pub fn run() {
 }
 
 #[cfg(test)]
-mod tests{
+mod tests {
     use super::*;
-    
+
     extern crate test;
     use test::Bencher;
 
     #[bench]
     fn bench_part_1(b: &mut Bencher) {
         let input = process_input(util::read_input("inputs/day1.txt").unwrap());
-        b.iter(|| {
-            part_1(&input)
-        });
+        b.iter(|| part_1(&input));
     }
 
     #[bench]
     fn bench_part_2(b: &mut Bencher) {
         let input = process_input(util::read_input("inputs/day1.txt").unwrap());
-        b.iter(||{
-            part_2(&input)
-        })
+        b.iter(|| part_2(&input))
     }
 }

src/days/day2.rs

@@ -13,45 +13,39 @@ impl From<&str> for Direction {
             "forward" => Direction::Forward,
             "down" => Direction::Down,
             "up" => Direction::Up,
-            _ => panic!()
+            _ => panic!(),
         }
     }
 }
 
 fn process_input(input: String) -> Vec<(Direction, i64)> {
-    input.lines()
+    input
+        .lines()
         .map(|line| {
             let cell: Vec<_> = line.trim().split_whitespace().collect();
             (Direction::from(cell[0]), cell[1].parse().unwrap())
-        }) 
+        })
         .collect()
 }
 
-fn part_1(input: &Vec<(Direction, i64)>) -> i64 {   
-    let position = input.iter()
-        .fold((0, 0), |acc, (dir, amt) | {
-            match dir {
-                Direction::Forward => (acc.0 + amt, acc.1),
-                Direction::Down => (acc.0, acc.1 + amt),
-                Direction::Up => (acc.0, acc.1 - amt),
-            }
-        });
+fn part_1(input: &Vec<(Direction, i64)>) -> i64 {
+    let position = input.iter().fold((0, 0), |acc, (dir, amt)| match dir {
+        Direction::Forward => (acc.0 + amt, acc.1),
+        Direction::Down => (acc.0, acc.1 + amt),
+        Direction::Up => (acc.0, acc.1 - amt),
+    });
     position.0 * position.1
 }
 
 fn part_2(input: &Vec<(Direction, i64)>) -> i64 {
-    let coordinates = input.iter()
-        .fold((0, 0, 0), |acc, (dir, amt)| {
-            match dir {
-                Direction::Forward => (acc.0 + amt, acc.1 + amt * acc.2, acc.2),
-                Direction::Down => (acc.0, acc.1, acc.2 + amt),
-                Direction::Up => (acc.0, acc.1, acc.2 - amt),
-            }
-        });
+    let coordinates = input.iter().fold((0, 0, 0), |acc, (dir, amt)| match dir {
+        Direction::Forward => (acc.0 + amt, acc.1 + amt * acc.2, acc.2),
+        Direction::Down => (acc.0, acc.1, acc.2 + amt),
+        Direction::Up => (acc.0, acc.1, acc.2 - amt),
+    });
     coordinates.0 * coordinates.1
 }
 
-
 pub fn run() {
     let input = util::read_input("inputs/day2.txt");
     let input = process_input(input.unwrap());
@@ -60,25 +54,21 @@ pub fn run() {
 }
 
 #[cfg(test)]
-mod tests{
+mod tests {
     use super::*;
-    
+
     extern crate test;
     use test::Bencher;
 
     #[bench]
     fn bench_part_1(b: &mut Bencher) {
         let input = process_input(util::read_input("inputs/day2.txt").unwrap());
-        b.iter(|| {
-            part_1(&input)
-        });
+        b.iter(|| part_1(&input));
     }
 
     #[bench]
     fn bench_part_2(b: &mut Bencher) {
         let input = process_input(util::read_input("inputs/day2.txt").unwrap());
-        b.iter(||{
-            part_2(&input)
-        })
+        b.iter(|| part_2(&input))
     }
 }

src/days/day3.rs

@@ -4,19 +4,18 @@ const WIDTH: usize = 12;
 const LENGTH: usize = 1000;
 
 fn get_most_common_bits(nums: Vec<usize>) -> Vec<usize> {
-    nums
-        .iter()
-        .fold(vec![0; WIDTH], |counts, bits| {
-            counts
-                .into_iter()
-                .enumerate()
-                .map(|(i, curr)| curr + ((bits & 1 << i) >> i))
-                .collect()
-        })
+    nums.iter().fold(vec![0; WIDTH], |counts, bits| {
+        counts
+            .into_iter()
+            .enumerate()
+            .map(|(i, curr)| curr + ((bits & 1 << i) >> i))
+            .collect()
+    })
 }
 
 fn part_1(input: &str) -> usize {
-    let nums:Vec<usize> = input.lines()
+    let nums: Vec<usize> = input
+        .lines()
         .map(|line| usize::from_str_radix(line.trim(), 2).unwrap())
         .collect();
     let counts = get_most_common_bits(nums);
@@ -33,20 +32,20 @@ fn part_1(input: &str) -> usize {
     gamma * epsilon
 }
 
-
 fn part_2(input: &str) -> usize {
-    let nums: Vec<usize> = input.lines()
+    let nums: Vec<usize> = input
+        .lines()
         .map(|line| usize::from_str_radix(line.trim(), 2).unwrap())
         .collect();
     let oxy = (0..WIDTH)
-    .rev()
-    .scan(nums.clone(), |oxy, i| {
-        let one = oxy.iter().filter(|n| *n & 1 << i > 0).count() >= (oxy.len() + 1) / 2;
-        oxy.drain_filter(|n| (*n & 1 << i > 0) != one);
-        oxy.first().copied()
-    })
-    .last()
-    .unwrap();
+        .rev()
+        .scan(nums.clone(), |oxy, i| {
+            let one = oxy.iter().filter(|n| *n & 1 << i > 0).count() >= (oxy.len() + 1) / 2;
+            oxy.drain_filter(|n| (*n & 1 << i > 0) != one);
+            oxy.first().copied()
+        })
+        .last()
+        .unwrap();
 
     let co2 = (0..WIDTH)
         .rev()
@@ -61,33 +60,28 @@ fn part_2(input: &str) -> usize {
     oxy * co2
 }
 
-
 pub fn run() {
     let input = util::read_input("inputs/day3.txt").unwrap();
     println!("part 1: {}", part_1(&input));
     println!("part 2: {}", part_2(&input));
 }
 
 #[cfg(test)]
-mod tests{
+mod tests {
     use super::*;
-    
+
     extern crate test;
     use test::Bencher;
 
     #[bench]
     fn bench_part_1(b: &mut Bencher) {
         let input = util::read_input("inputs/day3.txt").unwrap();
-        b.iter(|| {
-            part_1(&input)
-        });
+        b.iter(|| part_1(&input));
     }
 
     #[bench]
     fn bench_part_2(b: &mut Bencher) {
         let input = util::read_input("inputs/day3.txt").unwrap();
-        b.iter(||{
-            part_2(&input)
-        })
+        b.iter(|| part_2(&input))
     }
 }