From 2251854f9c24869307083419cd2ea9aefeb9485b Mon Sep 17 00:00:00 2001 From: Eryn Wells Date: Mon, 5 Dec 2022 20:57:32 -0800 Subject: [PATCH] RustFmt on all the things --- 2022/aoc2022/src/day1.rs | 14 ++++++--- 2022/aoc2022/src/day2.rs | 56 +++++++++++++++++++++------------- 2022/aoc2022/src/day3.rs | 66 +++++++++++++++++++--------------------- 2022/aoc2022/src/day4.rs | 36 +++++++++++++++------- 2022/aoc2022/src/day5.rs | 44 +++++++++++++++++++-------- 2022/aoc2022/src/file.rs | 2 +- 2022/aoc2022/src/main.rs | 15 +++------ 7 files changed, 138 insertions(+), 95 deletions(-) diff --git a/2022/aoc2022/src/day1.rs b/2022/aoc2022/src/day1.rs index 6793be1..791b5af 100644 --- a/2022/aoc2022/src/day1.rs +++ b/2022/aoc2022/src/day1.rs @@ -29,14 +29,18 @@ fn get_calorie_totals(lines: Lines) -> Result> { pub fn main(input_filename: &str) -> Result<()> { let line_reader = line_reader_for_file(input_filename) .expect(format!("Unable to create line reader for file: {}", input_filename).as_str()); - let elves = get_calorie_totals(line_reader) - .expect("Unable to get knapsack calorie totals"); + let elves = get_calorie_totals(line_reader).expect("Unable to get knapsack calorie totals"); - println!("Part 1: Elf with highest calorie count in knapsack: {}", elves[0]); + println!( + "Part 1: Elf with highest calorie count in knapsack: {}", + elves[0] + ); let sum_of_top_three = &elves[0] + &elves[1] + &elves[2]; - println!("Part 2: Elves with top 3 highest calorie counts in their knapsacks: {}, {}, {} = {}", - &elves[0], &elves[1], &elves[2], sum_of_top_three); + println!( + "Part 2: Elves with top 3 highest calorie counts in their knapsacks: {}, {}, {} = {}", + &elves[0], &elves[1], &elves[2], sum_of_top_three + ); Ok(()) } diff --git a/2022/aoc2022/src/day2.rs b/2022/aoc2022/src/day2.rs index 0b0d88a..c3ba35d 100644 --- a/2022/aoc2022/src/day2.rs +++ b/2022/aoc2022/src/day2.rs @@ -11,7 +11,11 @@ const SCORE_FOR_DRAW: i32 = 3; const SCORE_FOR_LOSS: i32 = 0; #[derive(Clone, Copy, PartialEq, PartialOrd)] -enum Shape { Rock, Paper, Scissors } +enum Shape { + Rock, + Paper, + Scissors, +} impl Shape { fn part1_from_string(s: &str) -> Option { @@ -68,7 +72,11 @@ impl Shape { } #[derive(Clone, Copy, PartialEq, PartialOrd)] -enum Outcome { Win, Draw, Loss } +enum Outcome { + Win, + Draw, + Loss, +} impl Outcome { fn part2_from_string(s: &str) -> Option { @@ -76,7 +84,7 @@ impl Outcome { "X" => Some(Outcome::Loss), "Y" => Some(Outcome::Draw), "Z" => Some(Outcome::Win), - _ => None + _ => None, } } @@ -103,27 +111,29 @@ struct Round { impl Round { fn part1_from_string(s: &str) -> Option { let split: Vec<&str> = s.split(" ").collect(); - match (Shape::part1_from_string(split[0]), Shape::part1_from_string(split[1])) { - (Some(opponents_shape), Some(my_shape)) => { - Some(Round { - me: my_shape, - outcome: Outcome::with_shapes(opponents_shape, my_shape) - }) - }, - _ => None + match ( + Shape::part1_from_string(split[0]), + Shape::part1_from_string(split[1]), + ) { + (Some(opponents_shape), Some(my_shape)) => Some(Round { + me: my_shape, + outcome: Outcome::with_shapes(opponents_shape, my_shape), + }), + _ => None, } } fn part2_from_string(s: &str) -> Option { let split: Vec<&str> = s.split(" ").collect(); - match (Shape::part2_from_string(split[0]), Outcome::part2_from_string(split[1])) { - (Some(opponents_shape), Some(expected_outcome)) => { - Some(Round { - me: Shape::part2_from_shape_and_outcome(opponents_shape, expected_outcome), - outcome: expected_outcome - }) - }, - _ => None + match ( + Shape::part2_from_string(split[0]), + Outcome::part2_from_string(split[1]), + ) { + (Some(opponents_shape), Some(expected_outcome)) => Some(Round { + me: Shape::part2_from_shape_and_outcome(opponents_shape, expected_outcome), + outcome: expected_outcome, + }), + _ => None, } } @@ -156,7 +166,8 @@ pub fn main(input_filename: &str) -> Result<()> { let mut part2_total_score: i32 = 0; for line in line_reader { - let line = line.expect(format!("Failed to read line after {} rounds!", number_of_rounds).as_str()); + let line = + line.expect(format!("Failed to read line after {} rounds!", number_of_rounds).as_str()); if let Some(round) = Round::part1_from_string(&line) { part1_total_score += round.score(); } @@ -168,7 +179,10 @@ pub fn main(input_filename: &str) -> Result<()> { println!("Processed {} rounds", number_of_rounds); println!("Part 1: total score two shapes: {}", part1_total_score); - println!("Part 2: total score with expected outcomes: {}", part2_total_score); + println!( + "Part 2: total score with expected outcomes: {}", + part2_total_score + ); Ok(()) } diff --git a/2022/aoc2022/src/day3.rs b/2022/aoc2022/src/day3.rs index aa6e7a5..c1cef3e 100644 --- a/2022/aoc2022/src/day3.rs +++ b/2022/aoc2022/src/day3.rs @@ -13,7 +13,10 @@ fn priority_items_in_knapsack(knapsack: &str) -> Vec { let left_compartment_set: HashSet = HashSet::from_iter(left_compartment.chars()); let right_compartment_set: HashSet = HashSet::from_iter(right_compartment.chars()); - left_compartment_set.intersection(&right_compartment_set).map(|c| *c).collect() + left_compartment_set + .intersection(&right_compartment_set) + .map(|c| *c) + .collect() } fn badge_for_group(group: (&str, &str, &str)) -> Vec { @@ -21,14 +24,8 @@ fn badge_for_group(group: (&str, &str, &str)) -> Vec { let b_set: HashSet = HashSet::from_iter(group.1.chars()); let c_set: HashSet = HashSet::from_iter(group.2.chars()); - let ab_intersection: HashSet = a_set - .intersection(&b_set) - .map(|c| *c) - .collect(); - ab_intersection - .intersection(&c_set) - .map(|c| *c) - .collect() + let ab_intersection: HashSet = a_set.intersection(&b_set).map(|c| *c).collect(); + ab_intersection.intersection(&c_set).map(|c| *c).collect() } pub fn main(filename: &str) -> Result<()> { @@ -52,33 +49,34 @@ pub fn main(filename: &str) -> Result<()> { const LOWERCASE_A_SCORE: u32 = 'a' as u32; const UPPERCASE_A_SCORE: u32 = 'A' as u32; - let sum_of_scored_priority_letters: u32 = - priority_letters - .iter() - .map(|c| -> u32 { - let char_value: u32 = (*c).into(); - if c.is_lowercase() { - char_value - LOWERCASE_A_SCORE + 1 - } else { - char_value - UPPERCASE_A_SCORE + 27 - } - }) - .sum(); + let sum_of_scored_priority_letters: u32 = priority_letters + .iter() + .map(|c| -> u32 { + let char_value: u32 = (*c).into(); + if c.is_lowercase() { + char_value - LOWERCASE_A_SCORE + 1 + } else { + char_value - UPPERCASE_A_SCORE + 27 + } + }) + .sum(); - println!("Part 1: sum of scores of all priority items: {}", sum_of_scored_priority_letters); + println!( + "Part 1: sum of scores of all priority items: {}", + sum_of_scored_priority_letters + ); - let sum_of_badges: u32 = - badges - .iter() - .map(|c| -> u32 { - let char_value: u32 = (*c).into(); - if c.is_lowercase() { - char_value - LOWERCASE_A_SCORE + 1 - } else { - char_value - UPPERCASE_A_SCORE + 27 - } - }) - .sum(); + let sum_of_badges: u32 = badges + .iter() + .map(|c| -> u32 { + let char_value: u32 = (*c).into(); + if c.is_lowercase() { + char_value - LOWERCASE_A_SCORE + 1 + } else { + char_value - UPPERCASE_A_SCORE + 27 + } + }) + .sum(); println!("Part 2: sum of badges: {}", sum_of_badges); diff --git a/2022/aoc2022/src/day4.rs b/2022/aoc2022/src/day4.rs index 1946cc1..80eef70 100644 --- a/2022/aoc2022/src/day4.rs +++ b/2022/aoc2022/src/day4.rs @@ -7,7 +7,9 @@ use crate::file::line_reader_for_file; struct RangeString(String); impl From<&str> for RangeString { - fn from(s: &str) -> Self { RangeString(s.to_string()) } + fn from(s: &str) -> Self { + RangeString(s.to_string()) + } } impl From for RangeInclusive { @@ -28,8 +30,8 @@ struct Assignment { impl Assignment { fn from_left_and_right_specifier( left_specifier: RangeString, - right_specifier: RangeString) -> Assignment - { + right_specifier: RangeString, + ) -> Assignment { Assignment { left: RangeInclusive::::from(left_specifier), right: RangeInclusive::::from(right_specifier), @@ -37,10 +39,10 @@ impl Assignment { } fn has_range_contained_by_other(&self) -> bool { - let left_contains_right = self.left.contains(self.right.start()) - && self.left.contains(self.right.end()); - let right_contains_left = self.right.contains(self.left.start()) - && self.right.contains(self.left.end()); + let left_contains_right = + self.left.contains(self.right.start()) && self.left.contains(self.right.end()); + let right_contains_left = + self.right.contains(self.left.start()) && self.right.contains(self.left.end()); left_contains_right || right_contains_left } @@ -60,21 +62,33 @@ pub fn main(filename: &str) -> Result<()> { let mut elves = line.split(",").map(|s| RangeString::from(s)); let assignment = Assignment::from_left_and_right_specifier( elves.next().unwrap(), - elves.next().unwrap()); + elves.next().unwrap(), + ); assert!(elves.next() == None); assignment }) .fold((0, 0, 0), |acc, a| { - let part1_counter = acc.1 + if a.has_range_contained_by_other() { 1 } else { 0 }; + let part1_counter = acc.1 + + if a.has_range_contained_by_other() { + 1 + } else { + 0 + }; let part2_counter = acc.2 + if a.has_overlapping_range() { 1 } else { 0 }; (acc.0 + 1, part1_counter, part2_counter) }); println!("Processed {} assignments", assignment_counts.0); - println!("Part 1: number of assignments with one range containing the other: {}", assignment_counts.1); - println!("Part 2: number of assignments with ranges at least partially overlapping: {}", assignment_counts.2); + println!( + "Part 1: number of assignments with one range containing the other: {}", + assignment_counts.1 + ); + println!( + "Part 2: number of assignments with ranges at least partially overlapping: {}", + assignment_counts.2 + ); Ok(()) } diff --git a/2022/aoc2022/src/day5.rs b/2022/aoc2022/src/day5.rs index f8ffd7a..53807ee 100644 --- a/2022/aoc2022/src/day5.rs +++ b/2022/aoc2022/src/day5.rs @@ -6,14 +6,17 @@ use crate::file::line_reader_for_file; #[derive(PartialEq)] enum State { StartingState, - Instructions + Instructions, } #[derive(Debug)] struct Stacks(Vec>); impl Stacks { - fn part1_perform(&mut self, instruction: &Instruction) -> std::result::Result<(), &'static str> { + fn part1_perform( + &mut self, + instruction: &Instruction, + ) -> std::result::Result<(), &'static str> { for _ in 0..instruction.quantity { let item = self.0[instruction.from_stack].pop().unwrap(); self.0[instruction.to_stack].push(item); @@ -21,7 +24,10 @@ impl Stacks { Ok(()) } - fn part2_perform(&mut self, instruction: &Instruction) -> std::result::Result<(), &'static str> { + fn part2_perform( + &mut self, + instruction: &Instruction, + ) -> std::result::Result<(), &'static str> { let from_stack_len: usize = self.0[instruction.from_stack].len(); let index_of_last_n = from_stack_len - instruction.quantity; @@ -40,10 +46,16 @@ impl Stacks { impl fmt::Display for Stacks { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "{}", self.0.iter().enumerate() - .map(|(i, v)| format!("{}: {}", i, v.join(", "))) - .collect::>() - .join("\n")) + write!( + f, + "{}", + self.0 + .iter() + .enumerate() + .map(|(i, v)| format!("{}: {}", i, v.join(", "))) + .collect::>() + .join("\n") + ) } } @@ -51,7 +63,7 @@ impl fmt::Display for Stacks { struct Instruction { quantity: usize, from_stack: usize, - to_stack: usize + to_stack: usize, } impl TryFrom<&str> for Instruction { @@ -92,7 +104,7 @@ impl TryFrom<&str> for Instruction { } Ok(Instruction { - quantity: quantity, + quantity: quantity, from_stack: from_stack, to_stack: to_stack, }) @@ -132,19 +144,25 @@ pub fn main(filename: &str) -> Result<()> { index_of_stack += 1; } - }, + } State::Instructions => { let instruction = Instruction::try_from(line.as_str()).unwrap(); let _ = part1_stacks.part1_perform(&instruction); let _ = part2_stacks.part2_perform(&instruction); - }, + } } } println!("{}", part1_stacks); - println!("Part 1: tops of stacks: {}", part1_stacks.tops().collect::>().join("")); + println!( + "Part 1: tops of stacks: {}", + part1_stacks.tops().collect::>().join("") + ); println!("{}", part2_stacks); - println!("Part 2: tops of stacks: {}", part2_stacks.tops().collect::>().join("")); + println!( + "Part 2: tops of stacks: {}", + part2_stacks.tops().collect::>().join("") + ); Ok(()) } diff --git a/2022/aoc2022/src/file.rs b/2022/aoc2022/src/file.rs index 8bcc97e..e2f1695 100644 --- a/2022/aoc2022/src/file.rs +++ b/2022/aoc2022/src/file.rs @@ -5,7 +5,7 @@ use std::io::Lines; use std::io::Result; pub fn line_reader_for_file(filename: &str) -> Result>> { - let file = File::open(filename)?; + let file = File::open(filename)?; let reader = BufReader::new(file); Ok(reader.lines()) } diff --git a/2022/aoc2022/src/main.rs b/2022/aoc2022/src/main.rs index a105ab9..43e6eee 100644 --- a/2022/aoc2022/src/main.rs +++ b/2022/aoc2022/src/main.rs @@ -14,26 +14,21 @@ fn main() { println!("----- Day 1 -----"); let day1_datafile = &args[1]; - day1::main(&day1_datafile) - .expect("Unable to process day1 data file"); + day1::main(&day1_datafile).expect("Unable to process day1 data file"); println!("----- Day 2 -----"); let day2_datafile = &args[2]; - day2::main(&day2_datafile) - .expect("Unable to process day2 data file"); + day2::main(&day2_datafile).expect("Unable to process day2 data file"); println!("----- Day 3 -----"); let day3_datafile = &args[3]; - day3::main(&day3_datafile) - .expect("Unable to process day3 data file"); + day3::main(&day3_datafile).expect("Unable to process day3 data file"); println!("----- Day 4 -----"); let day4_datafile = &args[4]; - day4::main(day4_datafile.as_str()) - .expect("Unable to process day4 data file"); + day4::main(day4_datafile.as_str()).expect("Unable to process day4 data file"); println!("----- Day 5 -----"); let day5_datafile = &args[5]; - day5::main(day5_datafile.as_str()) - .expect("Unable to process day5 data file"); + day5::main(day5_datafile.as_str()).expect("Unable to process day5 data file"); }