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

@@ -0,0 +1,171 @@
+use std::{io::BufRead, str::FromStr};
+
+use aoc_runner_derive::{aoc, aoc_generator};
+
+#[derive(Eq, PartialEq, Clone, Copy)]
+pub enum Shape {
+    Rock,
+    Paper,
+    Scissors,
+}
+
+impl FromStr for Shape {
+    type Err = Box<dyn std::error::Error>;
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        match value {
+            "A" | "X" => Ok(Self::Rock),
+            "B" | "Y" => Ok(Self::Paper),
+            "C" | "Z" => Ok(Self::Scissors),
+            c => Err(format!("Invalid shape `{c:?}`").into()),
+        }
+    }
+}
+
+impl Shape {
+    fn fight(&self, opponent: &Shape) -> Outcome {
+        match (self, opponent) {
+            (Self::Rock, Self::Scissors) | (Self::Scissors, Self::Paper) | (Self::Paper, Self::Rock) => Outcome::Win,
+            _ if self == opponent => Outcome::Tie,
+            _ => Outcome::Lose,
+        }
+    }
+    fn score(&self, opponent: &Shape) -> u64 {
+        self.points() + self.fight(opponent).points()
+    }
+    fn points(&self) -> u64 {
+        match self {
+            Shape::Rock => 1,
+            Shape::Paper => 2,
+            Shape::Scissors => 3,
+        }
+    }
+    // Return the Shape that will produce the desired outcome against us for the opponent
+    fn fix_round(&self, goal: &Outcome) -> Shape {
+        match goal {
+            Outcome::Tie => *self,
+            Outcome::Win => match self {
+                Shape::Rock => Shape::Paper,
+                Shape::Paper => Shape::Scissors,
+                Shape::Scissors => Shape::Rock,
+            },
+            Outcome::Lose => match self {
+                Shape::Rock => Shape::Scissors,
+                Shape::Paper => Shape::Rock,
+                Shape::Scissors => Shape::Paper,
+            },
+        }
+    }
+}
+
+pub enum Outcome {
+    Win,
+    Lose,
+    Tie,
+}
+
+impl Outcome {
+    fn points(&self) -> u64 {
+        match self {
+            Self::Win => 6,
+            Self::Tie => 3,
+            Self::Lose => 0,
+        }
+    }
+}
+
+impl FromStr for Outcome {
+    type Err = Box<dyn std::error::Error>;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "X" => Ok(Self::Lose),
+            "Y" => Ok(Self::Tie),
+            "Z" => Ok(Self::Win),
+            _ => Err(format!("Invalid outcome : `{s}").into()),
+        }
+    }
+}
+
+pub struct Move {
+    ours: Shape,
+    theirs: Shape,
+}
+
+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")?;
+        Ok(Move {
+            ours: ours.parse()?,
+            theirs: theirs.parse()?,
+        })
+    }
+}
+
+impl Move {
+    fn score(&self) -> u64 {
+        self.ours.score(&self.theirs)
+    }
+}
+
+pub struct MoveGoal {
+    theirs: Shape,
+    goal: Outcome,
+}
+
+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")?;
+        Ok(MoveGoal {
+            theirs: theirs.parse()?,
+            goal: goal.parse()?,
+        })
+    }
+}
+
+impl MoveGoal {
+    fn get_move(&self) -> Move {
+        Move {
+            theirs: self.theirs,
+            ours: self.theirs.fix_round(&self.goal),
+        }
+    }
+}
+
+#[aoc_generator(day2, part1)]
+fn parse_part1(input: &[u8]) -> Vec<Move> {
+    input.lines().map(|l| l.unwrap().parse().unwrap()).collect()
+}
+#[aoc_generator(day2, part2)]
+fn parse_part2(input: &[u8]) -> Vec<MoveGoal> {
+    input.lines().map(|l| l.unwrap().parse().unwrap()).collect()
+}
+
+#[aoc(day2, part1)]
+fn part1(input: &[Move]) -> u64 {
+    input.iter().map(|m| m.score()).sum()
+}
+
+#[aoc(day2, part2)]
+fn part2(input: &[MoveGoal]) -> u64 {
+    input.iter().map(|mg| mg.get_move().score()).sum()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const EXAMPLE: &[u8] = b"A Y
+B X
+C Z";
+
+    #[test]
+    fn part1_example() {
+        assert_eq!(part1(&parse_part1(EXAMPLE)), 15);
+    }
+
+    #[test]
+    fn part2_example() {
+        assert_eq!(part2(&parse_part2(EXAMPLE)), 12);
+    }
+}

src/day3.rs

@@ -0,0 +1,108 @@
+use aoc_runner_derive::{aoc, aoc_generator};
+use itertools::Itertools;
+use std::fmt::Display;
+
+struct Rucksack {
+    items: Vec<u8>,
+}
+
+impl From<&[u8]> for Rucksack {
+    fn from(s: &[u8]) -> Self {
+        Self { items: s.to_vec() }
+    }
+}
+
+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])
+        ))
+    }
+}
+
+impl Rucksack {
+    fn compartments(&self) -> [&[u8]; 2] {
+        let tup = self.items.split_at(self.items.len() / 2);
+        [tup.0, tup.1]
+    }
+    fn common(&self) -> u8 {
+        for item in self.compartments()[0] {
+            if self.compartments()[1].contains(item) {
+                return *item;
+            }
+        }
+        panic!("Common item not found");
+    }
+    fn common_with(&self, other: &[u8]) -> impl Iterator<Item = u8> {
+        self.compartments()
+            .into_iter()
+            .flatten()
+            .filter(|c| other.contains(c))
+            .cloned()
+    }
+}
+
+fn priority(c: u8) -> u8 {
+    if c.is_ascii_uppercase() {
+        c - b'A' + 27
+    } else if c.is_ascii_lowercase() {
+        c - b'a' + 1
+    } else {
+        panic!("Invalid item {c}")
+    }
+}
+
+#[aoc_generator(day3)]
+fn parse(input: &[u8]) -> Vec<Rucksack> {
+    input.split(|i| *i == b'\n').map(|x| x.into()).collect()
+}
+
+#[aoc(day3, part1)]
+fn part1(input: &[Rucksack]) -> u64 {
+    input.iter().map(|sack| priority(sack.common()) as u64).sum()
+}
+
+#[aoc(day3, part2)]
+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();
+        let commons = sacks[2].common_with(&commons_1).unique().collect_vec();
+
+        if commons.len() != 1 {
+            panic!(
+                "Wrong number ({}) of commons for sacks {} {} {}",
+                commons.len(),
+                sacks[0],
+                sacks[1],
+                sacks[2]
+            );
+        }
+        total += priority(commons[0]) as u64
+    }
+    total
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const EXAMPLE: &[u8] = b"vJrwpWtwJgWrhcsFMMfFFhFp
+jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL
+PmmdzqPrVvPwwTWBwg
+wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn
+ttgJtRGJQctTZtZT
+CrZsJsPPZsGzwwsLwLmpwMDw";
+
+    #[test]
+    fn part1_example() {
+        assert_eq!(part1(&parse(EXAMPLE)), 157);
+    }
+
+    #[test]
+    fn part2_example() {
+        assert_eq!(part2(&parse(EXAMPLE)), 70);
+    }
+}

src/day4.rs

@@ -0,0 +1,67 @@
+use std::ops::RangeInclusive;
+
+use aoc_runner_derive::{aoc, aoc_generator};
+
+struct Pair([RangeInclusive<u64>; 2]);
+
+impl From<&str> for Pair {
+    fn from(value: &str) -> Self {
+        let ranges = value.split_once(',').unwrap();
+        Pair([parse_range(ranges.0), parse_range(ranges.1)])
+    }
+}
+
+impl Pair {
+    fn fully_contained(&self) -> bool {
+        (self.0[0].start() <= self.0[1].start() && self.0[0].end() >= self.0[1].end())
+            || (self.0[1].start() <= self.0[0].start() && self.0[1].end() >= self.0[0].end())
+    }
+    fn overlaps(&self) -> bool {
+        self.0[0].contains(self.0[1].start())
+            || self.0[0].contains(self.0[1].end())
+            || self.0[1].contains(self.0[0].start())
+            || self.0[1].contains(self.0[0].end())
+    }
+}
+
+fn parse_range(s: &str) -> RangeInclusive<u64> {
+    let (lower, upper) = s.split_once('-').unwrap();
+    RangeInclusive::new(lower.parse().unwrap(), upper.parse().unwrap())
+}
+
+#[aoc_generator(day4)]
+fn parse(input: &str) -> Vec<Pair> {
+    input.lines().map(|l| l.into()).collect()
+}
+
+#[aoc(day4, part1)]
+fn part1(input: &[Pair]) -> u64 {
+    input.iter().filter(|p| p.fully_contained()).count() as u64
+}
+
+#[aoc(day4, part2)]
+fn part2(input: &[Pair]) -> u64 {
+    input.iter().filter(|p| p.overlaps()).count() as u64
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const EXAMPLE: &str = "2-4,6-8
+2-3,4-5
+5-7,7-9
+2-8,3-7
+6-6,4-6
+2-6,4-8";
+
+    #[test]
+    fn part1_example() {
+        assert_eq!(part1(&parse(EXAMPLE)), 2);
+    }
+
+    #[test]
+    fn part2_example() {
+        assert_eq!(part2(&parse(EXAMPLE)), 4);
+    }
+}

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);

src/lib.rs

@@ -1,6 +1,9 @@
+mod day4;
 mod day1;
+mod day2;
+mod day3;
 use aoc_runner_derive::aoc_lib;
 
-pub mod day6;
+mod day6;
 
 aoc_lib! { year = 2022 }