2023 day 10 part 1

aoc23/examples/day10_1_1.txt

@@ -0,0 +1,5 @@
+.....
+.S-7.
+.|.|.
+.L-J.
+.....

aoc23/examples/day10_1_2.txt

@@ -0,0 +1,5 @@
+..F7.
+.FJ|.
+SJ.L7
+|F--J
+LJ...

aoc23/src/main.rs

@@ -45,6 +45,7 @@ fn main() {
         7 => solve_day!(day07, &input),
         8 => solve_day!(day08, &input),
         9 => solve_day!(day09, &input),
+        10 => solve_day!(day10, &input),
         _ => println!("day not solved: {}", day),
     }
 }

aoc23/src/solutions.rs

@@ -6,4 +6,5 @@ pub mod day05;
 pub mod day06;
 pub mod day07;
 pub mod day08;
-pub mod day09;
+pub mod day09;
+pub mod day10;

aoc23/src/solutions/day10.rs

@@ -0,0 +1,130 @@
+use std::collections::{HashMap, VecDeque};
+
+use util::grid::{Coordinate, Direction};
+
+pub fn part1(input: &str) -> usize {
+    let (coordinates, start) = parse(input);
+    let circle = find_circle(start, &coordinates);
+
+    circle.len() / 2
+}
+
+pub fn part2(input: &str) -> usize {
+    0
+}
+
+fn find_circle(start: Coordinate, coordinates: &HashMap<Coordinate, char>) -> String {
+    let mut queue = init_queue(&start, coordinates);
+
+    while let Some((coordinate, direction, path)) = queue.pop_front() {
+        if coordinate == start {
+            return path;
+        }
+
+        let pipe = coordinates.get(&coordinate).unwrap();
+        let next_direction = next_direction(*pipe, direction);
+        let next_coordinate = coordinate.step(&next_direction, 1);
+        let mut next_path = path.clone();
+        next_path.push(*pipe);
+
+        queue.push_back((next_coordinate, next_direction, next_path));
+    }
+
+    unreachable!()
+}
+
+fn init_queue(
+    start: &Coordinate,
+    coordinates: &HashMap<Coordinate, char>,
+) -> VecDeque<(Coordinate, Direction, String)> {
+    [
+        Direction::Up,
+        Direction::Left,
+        Direction::Down,
+        Direction::Right,
+    ]
+    .into_iter()
+    .map(|direction| (start.step(&direction, 1), direction))
+    .filter(|(coordinate, direction)| {
+        coordinates.contains_key(coordinate)
+            && valid_directions(*coordinates.get(coordinate).unwrap(), direction)
+    })
+    .map(|(coordinate, direction)| (coordinate, direction, String::from("S")))
+    .collect()
+}
+
+fn next_direction(pipe: char, direction: Direction) -> Direction {
+    match (pipe, direction) {
+        ('|', Direction::Up) => Direction::Up,
+        ('|', Direction::Down) => Direction::Down,
+        ('-', Direction::Left) => Direction::Left,
+        ('-', Direction::Right) => Direction::Right,
+        ('L', Direction::Down) => Direction::Right,
+        ('L', Direction::Left) => Direction::Up,
+        ('J', Direction::Down) => Direction::Left,
+        ('J', Direction::Right) => Direction::Up,
+        ('7', Direction::Up) => Direction::Left,
+        ('7', Direction::Right) => Direction::Down,
+        ('F', Direction::Up) => Direction::Right,
+        ('F', Direction::Left) => Direction::Down,
+        _ => unreachable!(),
+    }
+}
+
+fn valid_directions(pipe: char, direction: &Direction) -> bool {
+    match (pipe, direction) {
+        ('|', Direction::Up | Direction::Down) => true,
+        ('-', Direction::Left | Direction::Right) => true,
+        ('L', Direction::Left | Direction::Down) => true,
+        ('J', Direction::Right | Direction::Down) => true,
+        ('7', Direction::Right | Direction::Up) => true,
+        ('F', Direction::Left | Direction::Up) => true,
+        ('S', _) => true,
+        _ => false,
+    }
+}
+
+fn parse(input: &str) -> (HashMap<Coordinate, char>, Coordinate) {
+    let mut coordinates = HashMap::new();
+    for (y, row) in input.lines().enumerate() {
+        for (x, cell) in row.chars().enumerate() {
+            if cell != '.' {
+                coordinates.insert(Coordinate::from(x as i32, y as i32), cell);
+            }
+        }
+    }
+
+    let start_position = find_start(input);
+
+    (coordinates, start_position)
+}
+
+fn find_start(input: &str) -> Coordinate {
+    for (y, row) in input.lines().enumerate() {
+        for (x, cell) in row.chars().enumerate() {
+            if cell == 'S' {
+                return Coordinate::from(x as i32, y as i32);
+            }
+        }
+    }
+    unreachable!()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const EXAMPLE_1: &str = include_str!("../../examples/day10_1_1.txt");
+    const EXAMPLE_2: &str = include_str!("../../examples/day10_1_2.txt");
+
+    #[test]
+    fn part1_ex() {
+        assert_eq!(4, part1(EXAMPLE_1));
+        assert_eq!(8, part1(EXAMPLE_2));
+    }
+
+    #[test]
+    fn part2_ex() {
+        assert_eq!(0, part2(INPUT));
+    }
+}