Solutions/2016

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "aoc-ornaments"
 description = "Advent of Code tools"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2024"
 rust-version = "1.85"
 authors = ["Alyssa Evans <alyda@me.com>"]
@@ -25,4 +25,5 @@ rand = "0.8"
 serde_json = "1.0"
 
 [dev-dependencies]
+bacon = "3.8"
 rstest = "0.24"

README.md

@@ -1,3 +1,10 @@
 # Advent of Code
 
-see the [Examples](./examples/) and [Solutions](./src/bin/) for more.
+## Tests
+
+`cargo install --locked bacon`
+`bacon test -- --bin BINARY_NAME`
+
+---
+
+see the [Examples](./examples/) and [Solutions](./src/bin/) for more.

src/bin/2015-12-02.rs

@@ -2,11 +2,9 @@
 
 use std::str::FromStr;
 
-use aoc_ornaments::{Part, Solution};
+use aoc_ornaments::{nom::parse_dimensions, Part, Solution};
 
-use nom::{
-    character::complete::{char, u32}, multi::separated_list1, IResult
-};
+use nom::IResult;
 
 type Width = u32;
 type Length = u32;
@@ -26,29 +24,16 @@ impl FromStr for Day {
     /// - `2x3x4` has dimensions `2`, `3`, and `4`.
     /// 
     fn from_str(input: &str) -> miette::Result<Self> {
-        let parsed = input.lines()
+        Ok(Self(input.lines()
             .map(|line| {
-                let (_, (l, w, h)) = Self::parse_dimensions(line).unwrap();
+                let (_, (l, w, h)) = parse_dimensions(line).unwrap();
 
                 (l, w, h)
-            }).collect();
-
-        Ok(Self(parsed))
+            }).collect()))
     }
 }
 
 impl Day {
-    fn parse_dimensions(input: &str) -> IResult<&str, (u32, u32, u32)> {
-        let (input, nums) = separated_list1(char('x'), u32)(input)?;
-        match nums.as_slice() {
-            [l, w, h] => Ok((input, (*l, *w, *h))),
-            _ => Err(nom::Err::Error(nom::error::Error::new(
-                input,
-                nom::error::ErrorKind::LengthValue
-            )))
-        }
-    }
-
     fn dimensions(sides: (u32, u32, u32)) -> u32 {
         let (l, w, h) = sides;
         let a = l * w;

src/bin/2016-12-01.rs

@@ -0,0 +1,121 @@
+//! # Day 1: No Time for a Taxicab
+//! 
+//! Manhattan Distance
+//! Cycle Detection
+//! 
+
+use std::str::FromStr;
+
+use aoc_ornaments::{spatial::{manhattan_distance, Direction, Position}, Part, Solution};
+use nom::{character::complete::{digit1, one_of}, sequence::tuple, IResult};
+
+#[derive(Debug, derive_more::Deref)]
+struct Day(Vec<Position>);
+
+impl FromStr for Day {
+    type Err = miette::Error;
+
+    fn from_str(input: &str) -> miette::Result<Self> {
+        let mut direction = Direction::Up;
+
+        Ok(Day(input.split(", ")
+            .map(|turn| {
+                let (_, (turn, distance)) = Self::parse_direction(turn)
+                    .expect("parse error");
+
+                match turn {
+                    'L' => direction = direction.turn_left(),
+                    'R' => direction = direction.turn_right(),
+                    _ => unreachable!()
+                }
+
+                (direction, distance)
+            })
+            .map(|(direction, distance)| {
+                match direction {
+                    Direction::Up | Direction::Down => {
+                        Position::new(0, distance) * direction.to_offset()
+                    },
+                    Direction::Left | Direction::Right => {
+                        Position::new(distance, 0) * direction.to_offset()
+                    },
+                }
+            })
+            .collect::<Vec<_>>()))
+    }
+}
+
+impl Day {
+    fn parse_direction(input: &str) -> IResult<&str, (char, i32)> {
+        tuple((one_of("LR"), digit1))(input)
+            .map(|(input, (turn, distance))| (input, (turn, distance.parse().unwrap())))
+    }
+}
+
+impl Solution for Day {
+    type Output = i32;
+
+    fn part1(&mut self) -> miette::Result<Self::Output> {
+        Ok(manhattan_distance(&Position::ZERO, &self.iter().sum()))
+    }
+
+    fn part2(&mut self) -> miette::Result<Self::Output> {
+        let mut visited = std::collections::HashSet::new();
+        let current = Position::ZERO;
+        visited.insert(Position::ZERO);
+
+        Ok(self.iter()
+            .flat_map(|straight_line| {
+                // Break down movement into unit steps
+                let unit = match (straight_line.x, straight_line.y) {
+                    (x, 0) => Position::new(x.signum(), 0),
+                    (0, y) => Position::new(0, y.signum()),
+                    _ => unreachable!(),
+                };
+                let steps = straight_line.x.abs().max(straight_line.y.abs());
+                (0..steps).map(move |_| unit)
+            })
+            .scan(current, |pos, step| {
+                *pos += step;
+                Some(*pos)
+            })
+            .find(|pos| !visited.insert(*pos))
+            .map(|pos| manhattan_distance(&Position::ZERO, &pos))
+            // can't find the Easter Bunny HQ
+            .expect("no position visited twice"))
+
+    }
+}
+
+fn main() -> miette::Result<()> {
+    let mut day = Day::from_str(include_str!("../inputs/2016-12-01.txt"))?;
+    let part1 = day.solve(Part::One)?;
+    let part2 = day.solve(Part::Two)?;
+
+    println!("Part 1: {}", part1);
+    println!("Part 2: {}", part2);
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use rstest::rstest;
+
+    #[rstest]
+    #[case("R2, L3", 5)]
+    #[case("R2, R2, R2", 2)]
+    #[case("R5, L5, R5, R3", 12)]
+    fn part_1(#[case] input: &str, #[case] expected: i32) {
+        let mut day = Day::from_str(input).unwrap();
+        assert_eq!(day.solve(Part::One).unwrap(), expected.to_string());
+    }
+
+    #[test]
+    fn part_2() {
+        let mut day = Day::from_str("R8, R4, R4, R8").unwrap();
+        assert_eq!(day.solve(Part::Two).unwrap(), "4");
+    }
+}

src/bin/2016-12-02.rs

@@ -0,0 +1,185 @@
+//! # Day 2: Bathroom Security
+//! 
+
+use std::{collections::HashMap, str::FromStr};
+
+use aoc_ornaments::{keypad::{ButtonPad, NumberPad3x3Telephone}, spatial::{Direction, Position}, Part, Solution};
+use nom::{character::complete::one_of, multi::many0, IResult};
+
+/// NewType impl for orphan rules
+#[derive(Debug, derive_more::Deref)]
+struct MyButtonPad(ButtonPad<DiamondPad>);
+
+#[derive(Debug)]
+struct DiamondPad;
+
+impl Default for MyButtonPad {
+    fn default() -> Self {
+        let mut map = HashMap::new();
+        map.insert('1', Position::new(2, 0));
+        map.insert('2', Position::ONE);
+        map.insert('3', Position::new(2, 1));
+        map.insert('4', Position::new(3, 1));
+        map.insert('5', Position::new(0, 2));
+        map.insert('6', Position::new(1, 2));
+        map.insert('7', Position::splat(2));
+        map.insert('8', Position::new(3, 2));
+        map.insert('9', Position::new(4, 2));
+        map.insert('A', Position::new(1, 3));
+        map.insert('B', Position::new(2, 3));
+        map.insert('C', Position::splat(3));
+        map.insert('D', Position::new(2, 4));
+
+        Self(ButtonPad::new(map))
+    }
+}
+
+#[derive(Debug, derive_more::Deref)]
+struct Day(Vec<Vec<Direction>>);
+
+impl FromStr for Day {
+    type Err = miette::Error;
+
+    fn from_str(input: &str) -> miette::Result<Self> {
+        Ok(Self(input.lines()
+            .map(|line| {
+                Day::to_directions(line).unwrap().1
+            })
+            .collect()))
+    }
+}
+
+impl Day {
+    fn to_directions(input: &str) -> IResult<&str, Vec<Direction>> {
+        let (_, chars) = many0(one_of("ULDR"))(input)?;
+
+        Ok(("", chars.iter().map(| c | {
+                Direction::parse(c).unwrap()
+            }).collect::<Vec<_>>()))
+    }
+
+    // ButtonPad<> and MyButtonPad are still different types and Generics are overkill
+    // fn to_digits(&self, pad: ) -> Vec<usize> {
+    //     let mut start = *pad.get(&'5').expect("Invalid start position (should be (1, 1)");
+
+    //     self.iter().map(|directions| {
+    //         for direction in directions {
+    //             let next = start + direction.to_offset();
+
+    //             if pad.values().any(|&pos| pos == next) {
+    //                 start = next;
+    //             }
+    //         }
+
+    //         pad.iter().find(|(_, pos)| **pos == start).unwrap().0
+
+    //     }).collect::<String>()
+    // }
+}
+
+impl Solution for Day {
+    type Output = String;
+
+    // `match` arms have incompatible types
+    // fn solve(&mut self, part: Part) -> miette::Result<String> {
+    //     let pad = match part {
+    //         Part::One => ButtonPad::<NumberPad3x3Telephone>::default(),
+    //         Part::Two => MyButtonPad::default(),
+    //         _ => unreachable!("Part 3 is not implemented"),
+    //     };
+
+    //     let mut start = *pad.get(&'5').expect("Invalid start position");
+
+    //     Ok(self.iter().map(|directions| {
+    //         for direction in directions {
+    //             let next = start + direction.to_offset();
+
+    //             if pad.values().any(|&pos| pos == next) {
+    //                 start = next;
+    //             }
+    //         }
+
+    //         pad.iter().find(|(_, pos)| **pos == start).unwrap().0
+
+    //     }).collect::<String>())
+    // }
+
+    fn part1(&mut self) -> miette::Result<Self::Output> {
+        let pad = ButtonPad::<NumberPad3x3Telephone>::default();
+
+        let mut start = *pad.get(&'5').expect("Invalid start position (should be (1, 1)");
+
+        Ok(self.iter().map(|directions| {
+            for direction in directions {
+                let next = start + direction.to_offset();
+
+                if pad.values().any(|&pos| pos == next) {
+                    start = next;
+                }
+            }
+
+            pad.iter().find(|(_, pos)| **pos == start).unwrap().0
+
+        }).collect::<String>())
+    }
+
+    fn part2(&mut self) -> miette::Result<Self::Output> {
+        let pad = MyButtonPad::default();
+
+        let mut start = *pad.get(&'5').expect("Invalid start position (should be (0, 2)");
+
+        Ok(self.iter().map(|directions| {
+            for direction in directions {
+                let next = start + direction.to_offset();
+
+                if pad.values().any(|&pos| pos == next) {
+                    start = next;
+                }
+            }
+
+            pad.iter().find(|(_, pos)| **pos == start).unwrap().0
+
+        }).collect::<String>())
+    }
+}
+
+fn main() -> miette::Result<()> {
+    let mut day = Day::from_str(include_str!("../inputs/2016-12-02.txt"))?;
+    let part1 = day.solve(Part::One)?;
+    let part2 = day.solve(Part::Two)?;
+
+    println!("Part 1: {}", part1);
+    println!("Part 2: {}", part2);
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use rstest::rstest;
+
+    #[test]
+    fn part_1() {
+        let input = "ULL\nRRDDD\nLURDL\nUUUUD";
+        let mut day = Day::from_str(input).unwrap();
+
+        assert_eq!(day.solve(Part::One).unwrap(), "1985");
+    }
+
+    #[rstest]
+    #[case("ULL", "5")]
+    fn test_cases(#[case] input: &str, #[case] expected: &str) {
+        let mut day = Day::from_str(input).unwrap();
+        assert_eq!(day.solve(Part::Two).unwrap(), expected);
+    }
+
+    #[test]
+    fn part_2() {
+        let input = "ULL\nRRDDD\nLURDL\nUUUUD";
+        let mut day = Day::from_str(input).unwrap();
+
+        assert_eq!(day.solve(Part::Two).unwrap(), "5DB3");
+    }
+}