From e3135f492fef8cca54cc3fd97db05797c205122d Mon Sep 17 00:00:00 2001 From: Xavier Morel Date: Thu, 5 Dec 2024 13:11:30 +0100 Subject: [PATCH] chore: fmt + clippy + time on day 5 --- README.md | 3 +- src/bin/05.rs | 105 +++++++++++++++++++++++++++----------------------- 2 files changed, 58 insertions(+), 50 deletions(-) diff --git a/README.md b/README.md index 5f849d6..5f4cdb0 100644 --- a/README.md +++ b/README.md @@ -25,8 +25,9 @@ Solutions for [Advent of Code](https://adventofcode.com/) in [Rust](https://www. | [Day 2](./src/bin/02.rs) | `215.6µs` | `371.6µs` | | [Day 3](./src/bin/03.rs) | `652.5µs` | `736.7µs` | | [Day 4](./src/bin/04.rs) | `5.6ms` | `2.4ms` | +| [Day 5](./src/bin/05.rs) | `3.7ms` | `9.7ms` | -**Total: 10.13ms** +**Total: 23.53ms** --- diff --git a/src/bin/05.rs b/src/bin/05.rs index e376cbc..a879285 100644 --- a/src/bin/05.rs +++ b/src/bin/05.rs @@ -2,25 +2,23 @@ advent_of_code::solution!(5); #[derive(Debug)] struct Rules { - rules: Vec<(u32, u32)> + rules: Vec<(u32, u32)>, } impl From<&[&str]> for Rules { fn from(lines: &[&str]) -> Self { let mut rules: Vec<(u32, u32)> = lines - .into_iter() - .map( - |line| { - let pages = line - .split("|") - .map(|page| page.parse::().expect("invalid numeric in rules")) - .collect::>(); - match pages.as_slice() { - [a, b] => (*a, *b), - _ => panic!("invalid input: invalid rule"), - } + .iter() + .map(|line| { + let pages = line + .split("|") + .map(|page| page.parse::().expect("invalid numeric in rules")) + .collect::>(); + match pages.as_slice() { + [a, b] => (*a, *b), + _ => panic!("invalid input: invalid rule"), } - ) + }) .collect(); rules.sort(); Self { rules } @@ -28,26 +26,24 @@ impl From<&[&str]> for Rules { } impl Rules { - fn pages_after(&self, page: u32) -> Vec:: { - self - .rules + fn pages_after(&self, page: u32) -> Vec { + self.rules .clone() .into_iter() .filter_map(|r| match r { (p1, p2) if p1 == page => Some(p2), - _ => None + _ => None, }) .collect() } - fn pages_before(&self, page: u32) -> Vec:: { - self - .rules + fn pages_before(&self, page: u32) -> Vec { + self.rules .clone() .into_iter() .filter_map(|r| match r { (p1, p2) if p2 == page => Some(p1), - _ => None + _ => None, }) .collect() } @@ -56,24 +52,28 @@ impl Rules { let mut pages_with_order: Vec<(u32, Vec, Vec)> = pages .clone() .into_iter() - .map(|p| + .map(|p| { ( p, - self.pages_before(p).into_iter().filter(|pp| pages.contains(pp)).collect(), - self.pages_after(p).into_iter().filter(|pp| pages.contains(pp)).collect(), + self.pages_before(p) + .into_iter() + .filter(|pp| pages.contains(pp)) + .collect(), + self.pages_after(p) + .into_iter() + .filter(|pp| pages.contains(pp)) + .collect(), ) - ) + }) .collect(); - pages_with_order.sort_by_key( - |(p, before, after)| (before.len(), after.len()) - ); + pages_with_order.sort_by_key(|(_, before, after)| (before.len(), after.len())); pages_with_order.into_iter().map(|(p, _, _)| p).collect() } } #[derive(Debug)] struct ImpressionOrder { - pages: Vec + pages: Vec, } impl ImpressionOrder { @@ -82,16 +82,16 @@ impl ImpressionOrder { if length % 2 == 0 { None } else { - Some(self.pages[ (length / 2) as usize ]) + Some(self.pages[length / 2]) } } fn fix_order(&self, rules: &Rules) -> Self { Self { - pages: rules.get_correct_pages_order(self.pages.clone()) + pages: rules.get_correct_pages_order(self.pages.clone()), } } - + fn is_valid(&self, rules: &Rules) -> bool { let mut invalid_pages: Vec = Vec::new(); for p in self.pages.clone() { @@ -107,41 +107,48 @@ impl ImpressionOrder { impl TryFrom<&&str> for ImpressionOrder { type Error = (); fn try_from(line: &&str) -> Result { - let pages = line.split(",").flat_map(|page| page.parse::()).collect::>(); + let pages = line + .split(",") + .flat_map(|page| page.parse::()) + .collect::>(); Ok(Self { pages }) } } pub fn part_one(input: &str) -> Option { - let input = input - .lines() - .collect::>(); - let input = input - .split(|s|s.is_empty()) - .collect::>(); + let input = input.lines().collect::>(); + let input = input.split(|s| s.is_empty()).collect::>(); let rules: Rules = input[0].into(); input[1] - .into_iter() + .iter() .flat_map(ImpressionOrder::try_from) - .filter_map(|o| if o.is_valid(&rules) { o.middle_page() } else { None }) + .filter_map(|o| { + if o.is_valid(&rules) { + o.middle_page() + } else { + None + } + }) .sum::() .into() } pub fn part_two(input: &str) -> Option { - let input = input - .lines() - .collect::>(); - let input = input - .split(|s|s.is_empty()) - .collect::>(); + let input = input.lines().collect::>(); + let input = input.split(|s| s.is_empty()).collect::>(); let rules: Rules = input[0].into(); input[1] - .into_iter() + .iter() .flat_map(ImpressionOrder::try_from) - .filter_map(|o| if !o.is_valid(&rules) { o.fix_order(&rules).middle_page() } else { None }) + .filter_map(|o| { + if !o.is_valid(&rules) { + o.fix_order(&rules).middle_page() + } else { + None + } + }) .sum::() .into() }