cleanup

src/day1.rs

@@ -20,12 +20,12 @@ fn parse(input: &[u8]) -> Vec<u64> {
 }
 
 #[aoc(day1, part1)]
-fn part1(input: &Vec<u64>) -> u64 {
+fn part1(input: &[u64]) -> u64 {
     *input.iter().max().unwrap()
 }
 
 #[aoc(day1, part2)]
-fn part2(input: &Vec<u64>) -> u64 {
+fn part2(input: &[u64]) -> u64 {
     input.iter().sorted().rev().take(3).sum::<u64>()
 }
 

src/day2.rs

@@ -93,7 +93,7 @@ pub struct Move {
 impl FromStr for Move {
     type Err = Box<dyn std::error::Error>;
     fn from_str(value: &str) -> Result<Self, Self::Err> {
-        let (theirs, ours) = value.split_once(&" ").ok_or("Unable to split")?;
+        let (theirs, ours) = value.split_once(" ").ok_or("Unable to split")?;
         Ok(Move {
             ours: ours.parse()?,
             theirs: theirs.parse()?,
@@ -115,7 +115,7 @@ pub struct MoveGoal {
 impl FromStr for MoveGoal {
     type Err = Box<dyn std::error::Error>;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let (theirs, goal) = s.split_once(&" ").ok_or("Unable to split")?;
+        let (theirs, goal) = s.split_once(" ").ok_or("Unable to split")?;
         Ok(MoveGoal {
             theirs: theirs.parse()?,
             goal: goal.parse()?,
@@ -142,12 +142,12 @@ fn parse_part2(input: &[u8]) -> Vec<MoveGoal> {
 }
 
 #[aoc(day2, part1)]
-fn part1(input: &Vec<Move>) -> u64 {
+fn part1(input: &[Move]) -> u64 {
     input.iter().map(|m| m.score()).sum()
 }
 
 #[aoc(day2, part2)]
-fn part2(input: &Vec<MoveGoal>) -> u64 {
+fn part2(input: &[MoveGoal]) -> u64 {
     input.iter().map(|mg| mg.get_move().score()).sum()
 }
 

src/day3.rs

@@ -8,9 +8,7 @@ struct Rucksack {
 
 impl From<&[u8]> for Rucksack {
     fn from(s: &[u8]) -> Self {
-        Self {
-            items: s.iter().cloned().collect(),
-        }
+        Self { items: s.to_vec() }
     }
 }
 
@@ -18,8 +16,8 @@ impl Display for Rucksack {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_fmt(format_args!(
             "{}{}",
-            String::from_utf8_lossy(&self.compartments()[0]),
-            String::from_utf8_lossy(&self.compartments()[1])
+            String::from_utf8_lossy(self.compartments()[0]),
+            String::from_utf8_lossy(self.compartments()[1])
         ))
     }
 }
@@ -31,16 +29,13 @@ impl Rucksack {
     }
     fn common(&self) -> u8 {
         for item in self.compartments()[0] {
-            if self.compartments()[1].contains(&item) {
+            if self.compartments()[1].contains(item) {
                 return *item;
             }
         }
         panic!("Common item not found");
     }
-    fn contains(&self, item: &u8) -> bool {
-        self.compartments().into_iter().flatten().contains(item)
-    }
-    fn common_with<'a>(&self, other: &[u8]) -> impl Iterator<Item = u8> {
+    fn common_with(&self, other: &[u8]) -> impl Iterator<Item = u8> {
         self.compartments()
             .into_iter()
             .flatten()
@@ -50,9 +45,9 @@ impl Rucksack {
 }
 
 fn priority(c: u8) -> u8 {
-    if c >= b'A' && c <= b'Z' {
+    if c.is_ascii_uppercase() {
         c - b'A' + 27
-    } else if c >= b'a' && c <= b'z' {
+    } else if c.is_ascii_lowercase() {
         c - b'a' + 1
     } else {
         panic!("Invalid item {c}")
@@ -65,12 +60,12 @@ fn parse(input: &[u8]) -> Vec<Rucksack> {
 }
 
 #[aoc(day3, part1)]
-fn part1(input: &Vec<Rucksack>) -> u64 {
+fn part1(input: &[Rucksack]) -> u64 {
     input.iter().map(|sack| priority(sack.common()) as u64).sum()
 }
 
 #[aoc(day3, part2)]
-fn part2(input: &Vec<Rucksack>) -> u64 {
+fn part2(input: &[Rucksack]) -> u64 {
     let mut total = 0u64;
     for sacks in input.chunks(3) {
         let commons_1 = sacks[0].common_with(&sacks[1].items).unique().collect_vec();

src/day4.rs

@@ -1,4 +1,4 @@
-use std::{io::BufRead, ops::RangeInclusive};
+use std::ops::RangeInclusive;
 
 use aoc_runner_derive::{aoc, aoc_generator};
 
@@ -35,12 +35,12 @@ fn parse(input: &str) -> Vec<Pair> {
 }
 
 #[aoc(day4, part1)]
-fn part1(input: &Vec<Pair>) -> u64 {
+fn part1(input: &[Pair]) -> u64 {
     input.iter().filter(|p| p.fully_contained()).count() as u64
 }
 
 #[aoc(day4, part2)]
-fn part2(input: &Vec<Pair>) -> u64 {
+fn part2(input: &[Pair]) -> u64 {
     input.iter().filter(|p| p.overlaps()).count() as u64
 }
 

src/day6.rs

@@ -42,7 +42,7 @@ fn part2(input: &[u8]) -> u64 {
                     return None;
                 }
             }
-            return Some(i + 14);
+            Some(i + 14)
         })
         .unwrap() as u64
 }
@@ -57,7 +57,7 @@ mod tests {
     const EXAMPLE4: &[u8] = b"zcfzfwzzqfrljwzlrfnpqdbhtmscgvjw";
 
     #[test]
-    fn problem1_example() {
+    fn part1_example() {
         assert_eq!(part1(EXAMPLE1), 5);
         assert_eq!(part1(EXAMPLE2), 6);
         assert_eq!(part1(EXAMPLE3), 10);
@@ -65,7 +65,7 @@ mod tests {
     }
 
     #[test]
-    fn problem2_example() {
+    fn part2_example() {
         assert_eq!(part2(EXAMPLE1), 23);
         assert_eq!(part2(EXAMPLE2), 23);
         assert_eq!(part2(EXAMPLE3), 29);