Day 14

Author: prevostc

README.md

@@ -24,8 +24,9 @@ Solutions for [Advent of Code](https://adventofcode.com/) in [Rust](https://www.
 | [Day 11](./src/bin/11.rs) | `284.6µs` | `12.8ms` |
 | [Day 12](./src/bin/12.rs) | `434.7µs` | `674.6µs` |
 | [Day 13](./src/bin/13.rs) | `90.9µs` | `91.8µs` |
+| [Day 14](./src/bin/14.rs) | `31.0µs` | `3.6ms` |
 
-**Total: 27.08ms**
+**Total: 30.71ms**
 <!--- benchmarking table --->
 
 ---

data/examples/14.txt

@@ -0,0 +1,12 @@
+p=0,4 v=3,-3
+p=6,3 v=-1,-3
+p=10,3 v=-1,2
+p=2,0 v=2,-1
+p=0,0 v=1,3
+p=3,0 v=-2,-2
+p=7,6 v=-1,-3
+p=3,0 v=-1,-2
+p=9,3 v=2,3
+p=7,3 v=-1,2
+p=2,4 v=2,-3
+p=9,5 v=-3,-3

mygrid/src/direction.rs

@@ -198,6 +198,15 @@ impl Mul<i32> for Direction {
     }
 }
 
+impl Mul<u32> for Direction {
+    type Output = Direction;
+
+    #[inline]
+    fn mul(self, rhs: u32) -> Self::Output {
+        self * (rhs as isize)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/bin/14.rs

@@ -0,0 +1,164 @@
+use mygrid::{direction::Direction, grid::Grid, point::Point};
+
+advent_of_code::solution!(14);
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+struct Robot {
+    position: Point,
+    velocity: Direction,
+}
+
+#[derive(Debug, Clone)]
+struct Configuration {
+    seconds: u32,
+    grid_size: Point,
+    robots: Vec<Robot>,
+}
+
+#[inline]
+fn parse_input(input: &str) -> Vec<Robot> {
+    input
+        .lines()
+        .filter(|line| !line.is_empty())
+        .map(|line| {
+            let (position, velocity) = line[2..].split_once(" v=").unwrap();
+
+            let (px, py) = position.split_once(",").unwrap();
+            let (vx, vy) = velocity.split_once(",").unwrap();
+            Robot {
+                position: Point::new(py.parse().unwrap(), px.parse().unwrap()),
+                velocity: Direction::new(vy.parse().unwrap(), vx.parse().unwrap()),
+            }
+        })
+        .collect()
+}
+
+#[inline]
+fn wrap_position(position: Point, grid_size: Point) -> Point {
+    Point::new(
+        (position.line % grid_size.line + grid_size.line) % grid_size.line,
+        (position.column % grid_size.column + grid_size.column) % grid_size.column,
+    )
+}
+
+fn solve_p1(configuration: Configuration) -> u32 {
+    let result = configuration
+        .robots
+        .iter()
+        .map(|robot| {
+            let position = robot.position + (robot.velocity * configuration.seconds);
+            let wrapped_position = wrap_position(position, configuration.grid_size);
+            wrapped_position
+        })
+        .fold((0, 0, 0, 0), |mut acc, position| {
+            let middle_line = configuration.grid_size.line / 2;
+            let middle_column = configuration.grid_size.column / 2;
+            // find out the quadrant of the position
+            let left = position.line < middle_line;
+            let right = position.line > middle_line;
+            let top = position.column < middle_column;
+            let bottom = position.column > middle_column;
+
+            acc.0 += (top && left) as u32;
+            acc.1 += (bottom && left) as u32;
+            acc.2 += (top && right) as u32;
+            acc.3 += (bottom && right) as u32;
+            acc
+        });
+
+    result.0 * result.1 * result.2 * result.3
+}
+
+pub fn part_one(input: &str) -> Option<u32> {
+    let configuration = Configuration {
+        seconds: 100,
+        grid_size: Point::new(103, 101),
+        robots: parse_input(input),
+    };
+
+    Some(solve_p1(configuration))
+}
+
+pub fn part_two(input: &str) -> Option<u32> {
+    let mut configuration = Configuration {
+        seconds: 100,
+        grid_size: Point::new(103, 101),
+        robots: parse_input(input),
+    };
+
+    let base_dbg_grid = Grid::new(
+        configuration.grid_size.column as usize,
+        configuration.grid_size.line as usize,
+        '.',
+    );
+
+    let mut seconds = 0;
+
+    while seconds < 10000 {
+        let mut dbg_grid = base_dbg_grid.clone();
+
+        for robot in configuration.robots.iter_mut() {
+            let position = robot.position + robot.velocity;
+            let wrapped_position = wrap_position(position, configuration.grid_size);
+            robot.position = wrapped_position;
+        }
+        seconds += 1;
+
+        let robot_on_column_count = configuration
+            .robots
+            .iter()
+            // found visually
+            .filter(|&r| r.position.column > 24 && r.position.column < 55)
+            .count();
+        if robot_on_column_count > 200 {
+            for robot in configuration.robots.iter() {
+                dbg_grid[robot.position] = '#';
+            }
+            // dbg!(&dbg_grid);
+            // dbg!(&seconds);
+
+            //let mut buffer = String::new();
+            //std::io::stdin()
+            //    .read_line(&mut buffer)
+            //    .expect("Failed to read line");
+
+            // found visually
+            if seconds == 7083 {
+                return Some(seconds);
+            }
+        }
+    }
+
+    Some(seconds)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_one_robot() {
+        let configuration = Configuration {
+            seconds: 2,
+            grid_size: Point::new(7, 11),
+            robots: vec![Robot {
+                position: Point::new(4, 2),
+                velocity: Direction::new(-3, 2),
+            }],
+        };
+
+        let result = solve_p1(configuration);
+        assert_eq!(result, 0);
+    }
+
+    #[test]
+    fn test_part_one() {
+        let configuration = Configuration {
+            seconds: 100,
+            grid_size: Point::new(7, 11),
+            robots: parse_input(&advent_of_code::template::read_file("examples", DAY)),
+        };
+        let result = solve_p1(configuration);
+        assert_eq!(result, 12);
+    }
+}