Day 15

Author: ochsnerd

src/day02.rs

@@ -1,5 +1,6 @@
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::hash::Hash;
+use crate::util::IteratorExt;
 
 pub fn solve(input: &str) -> (usize, usize) {
     let input = parse_input(input);
@@ -132,84 +133,3 @@ where
         .into_iter()
         .collect()
 }
-
-
-// upside: can be chained nicely, is lazy
-// downside: need clonable, up to 2x memory requirements
-struct Uniques<I, T>
-where
-    T: Eq + Hash + Clone,
-    I: Iterator<Item = T>,
-{
-    input: I,
-    seen: HashSet<T>,
-}
-
-impl<I, T> Uniques<I, T>
-where
-    T: Eq + Hash + Clone,
-    I: Iterator<Item = T>,
-{
-    fn new(input: I) -> Self {
-        Self {
-            input,
-            seen: HashSet::new(),
-        }
-    }
-}
-
-impl<I, T> Iterator for Uniques<I, T>
-where
-    T: Eq + Hash + Clone,
-    I: Iterator<Item = T>,
-{
-    type Item = T;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        while let Some(item) = self.input.next() {
-            if self.seen.insert(item.clone()) {
-                return Some(item);
-            }
-        }
-        None
-    }
-}
-
-// Extension trait to make it convenient to use
-trait IteratorExt: Iterator {
-    fn uniques(self) -> Uniques<Self, Self::Item>
-    where
-        Self: Sized,
-        Self::Item: Eq + Hash + Clone,
-    {
-        Uniques::new(self)
-    }
-}
-
-impl<I: Iterator> IteratorExt for I {}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_uniques() {
-        let input = vec![1, 2, 3, 2, 4, 1, 5];
-        let result: Vec<i32> = input.into_iter().uniques().collect();
-        assert_eq!(result, vec![1, 2, 3, 4, 5]);
-    }
-
-    #[test]
-    fn test_uniques_strings() {
-        let input = vec!["a", "b", "c", "b", "a", "d"];
-        let result: Vec<&str> = input.into_iter().uniques().collect();
-        assert_eq!(result, vec!["a", "b", "c", "d"]);
-    }
-
-    #[test]
-    fn test_empty() {
-        let input: Vec<i32> = vec![];
-        let result: Vec<i32> = input.into_iter().uniques().collect();
-        assert_eq!(result, vec![]);
-    }
-}

src/day15.rs

@@ -0,0 +1,238 @@
+use core::fmt;
+
+use crate::{
+    grid::{dyadic, Direction, Grid, GridParser, Index, Point, Vector},
+    util::bfs,
+};
+
+pub fn solve(input: &str) -> (usize, usize) {
+    let (mut warehouse, movements) = parse(input);
+    let mut warehouse2 = warehouse.clone().into_part2();
+    (
+        part1(&mut warehouse, &movements),
+        part2(&mut warehouse2, &movements),
+    )
+}
+
+fn part1(warehouse: &mut Warehouse, movements: &[Direction]) -> usize {
+    for &m in movements.into_iter() {
+        warehouse.do_move(m)
+    }
+    warehouse.score()
+}
+
+fn part2(warehouse: &mut Warehouse2, movements: &[Direction]) -> usize {
+    for &m in movements.into_iter() {
+        warehouse.do_move(m)
+    }
+    warehouse.score()
+}
+
+fn score(i: Index) -> usize {
+    let (x, y) = i.into();
+    x + y * 100
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum Thing {
+    Wall,
+    Box,
+    Floor,
+}
+
+#[derive(Debug, Clone)]
+struct Warehouse {
+    robot: Point,
+    map: Grid<Thing>,
+}
+
+impl Warehouse {
+    fn new(plan: &str) -> Warehouse {
+        // Here we iterate twice over plan - this not cost a meaningful amount of time
+        let map = GridParser::from([
+            ('#', Thing::Wall),
+            ('.', Thing::Floor),
+            ('O', Thing::Box),
+            ('@', Thing::Floor),
+        ])
+        .parse(plan)
+        .unwrap();
+        Warehouse {
+            robot: plan
+                .lines()
+                .flat_map(|l| l.chars())
+                .enumerate()
+                .filter_map(|(i, c)| match c {
+                    '@' => Some(dyadic(map.size, i).try_into().unwrap()),
+                    _ => None,
+                })
+                .next()
+                .unwrap(),
+            map,
+        }
+    }
+
+    fn do_move(&mut self, movement: Direction) {
+        let step = movement.into();
+        let start = self.robot + step;
+        let mut end = start;
+
+        while self.map.at_point(end) == Some(&Thing::Box) {
+            end += step;
+        }
+
+        if self.map.at_point(end) == Some(&Thing::Wall) {
+            // blocked
+            return;
+        }
+
+        self.robot = start;
+        self.map
+            .swap(start.try_into().unwrap(), end.try_into().unwrap());
+    }
+
+    fn score(&self) -> usize {
+        self.map
+            .iter_indices()
+            .filter(|&i| self.map[i] == Thing::Box)
+            .map(score)
+            .sum()
+    }
+
+    fn into_part2(self) -> Warehouse2 {
+        Warehouse2 {
+            robot: self.robot.scaled_x(2),
+            map: Grid::new(
+                (self.map.size.0 * 2, self.map.size.1),
+                self.map
+                    .elements
+                    .into_iter()
+                    .flat_map(|t| match t {
+                        Thing::Wall => [Thing2::Wall, Thing2::Wall],
+                        Thing::Box => [Thing2::BoxLeft, Thing2::BoxRight],
+                        Thing::Floor => [Thing2::Floor, Thing2::Floor],
+                    })
+                    .collect(),
+            ),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum Thing2 {
+    Wall,
+    BoxLeft,
+    BoxRight,
+    Floor,
+}
+
+fn is_box(t: &Thing2) -> bool {
+    t == &Thing2::BoxLeft || t == &Thing2::BoxRight
+}
+
+#[derive(Debug)]
+struct Warehouse2 {
+    robot: Point,
+    map: Grid<Thing2>,
+}
+
+impl Warehouse2 {
+    fn do_move(&mut self, movement: Direction) {
+        let step = movement.into();
+        self.push(self.robot, step);
+        if self.map.at_point(self.robot + step) == Some(&Thing2::Floor) {
+            self.robot += step;
+        }
+    }
+
+    fn push(&mut self, pos: Point, step: Vector) {
+        let pushes = |p| {
+            let next = p + step;
+            if self.map.at_point(next).is_some_and(is_box) {
+                vec![next, Warehouse2::other_box(&self.map, next).unwrap()]
+            } else {
+                Vec::new()
+            }
+        };
+
+        let potentially_pushed: Vec<_> = bfs(vec![pos], |&p| pushes(p)).skip(1).collect();
+
+        if potentially_pushed
+            .iter()
+            .any(|&p| self.map.at_point(p + step) == Some(&Thing2::Wall))
+        {
+            return;
+        }
+
+        // note: rev works here because we did a bfs
+        for p in potentially_pushed.into_iter().rev() {
+            self.map
+                .swap(p.try_into().unwrap(), (p + step).try_into().unwrap());
+        }
+    }
+
+    fn other_box(map: &Grid<Thing2>, p: Point) -> Option<Point> {
+        match map.at_point(p) {
+            Some(&Thing2::BoxLeft) => Some(p + Direction::Right.into()),
+            Some(&Thing2::BoxRight) => Some(p + Direction::Left.into()),
+            _ => None,
+        }
+    }
+
+    fn score(&self) -> usize {
+        self.map
+            .iter_indices()
+            .filter(|&i| self.map[i] == Thing2::BoxLeft)
+            .map(score)
+            .sum()
+    }
+}
+
+// no error handling ¯\_(ツ)_/¯
+fn parse(input: &str) -> (Warehouse, Vec<Direction>) {
+    fn from_arrow(a: char) -> Direction {
+        match a {
+            '^' => Direction::Up,
+            '>' => Direction::Right,
+            'v' => Direction::Down,
+            '<' => Direction::Left,
+            _ => panic!("Not an arrow"),
+        }
+    }
+    let mut blocks = input.split("\n\n");
+    if let (Some(warehouse_plan), Some(movements)) = (blocks.next(), blocks.next()) {
+        return (
+            Warehouse::new(warehouse_plan),
+            movements
+                .lines()
+                .flat_map(|l| l.chars().map(from_arrow))
+                .collect(),
+        );
+    }
+    panic!("Input looks unexpected");
+}
+
+impl fmt::Display for Warehouse2 {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fn to_char(t: Thing2) -> char {
+            match t {
+                Thing2::Wall => '#',
+                Thing2::BoxLeft => '[',
+                Thing2::BoxRight => ']',
+                Thing2::Floor => '.',
+            }
+        }
+        let robot = self.robot.try_into().unwrap();
+        for row in self.map.iter_indices_by_rows().into_iter() {
+            for idx in row {
+                if idx == robot {
+                    write!(f, "@")?;
+                } else {
+                    write!(f, "{}", to_char(self.map[idx]))?;
+                }
+            }
+            write!(f, "\n")?;
+        }
+        Ok(())
+    }
+}