Year 2017 Day 22

Author: maneatingape

Diff for: README.md

@@ -257,6 +257,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 19 | [A Series of Tubes](https://adventofcode.com/2017/day/19) | [Source](src/year2017/day19.rs) | 20 |
 | 20 | [Particle Swarm](https://adventofcode.com/2017/day/20) | [Source](src/year2017/day20.rs) | 234 |
 | 21 | [Fractal Art](https://adventofcode.com/2017/day/21) | [Source](src/year2017/day21.rs) | 4 |
+| 22 | [Sporifica Virus](https://adventofcode.com/2017/day/22) | [Source](src/year2017/day22.rs) | 36000 |
 | 23 | [Coprocessor Conflagration](https://adventofcode.com/2017/day/23) | [Source](src/year2017/day23.rs) | 55 |
 | 24 | [Electromagnetic Moat](https://adventofcode.com/2017/day/24) | [Source](src/year2017/day24.rs) | 280 |
 | 25 | [The Halting Problem](https://adventofcode.com/2017/day/25) | [Source](src/year2017/day25.rs) | 3597 |

Diff for: benches/benchmark.rs

@@ -122,6 +122,7 @@ mod year2017 {
     benchmark!(year2017, day19);
     benchmark!(year2017, day20);
     benchmark!(year2017, day21);
+    benchmark!(year2017, day22);
     benchmark!(year2017, day23);
     benchmark!(year2017, day24);
     benchmark!(year2017, day25);

Diff for: src/lib.rs

@@ -104,6 +104,7 @@ pub mod year2017 {
     pub mod day19;
     pub mod day20;
     pub mod day21;
+    pub mod day22;
     pub mod day23;
     pub mod day24;
     pub mod day25;

Diff for: src/main.rs

@@ -169,6 +169,7 @@ fn year2017() -> Vec<Solution> {
         solution!(year2017, day19),
         solution!(year2017, day20),
         solution!(year2017, day21),
+        solution!(year2017, day22),
         solution!(year2017, day23),
         solution!(year2017, day24),
         solution!(year2017, day25),

Diff for: src/year2017/day22.rs

@@ -0,0 +1,67 @@
+//! # Sporifica Virus
+//!
+//! Brute force solution using a fixed size grid, relying on the properties of the input to never
+//! exceed the bounds. Some bit manipulation tricks are used to speeds things up slightly.
+use crate::util::grid::*;
+use crate::util::point::*;
+
+pub fn parse(input: &str) -> Grid<u8> {
+    Grid::parse(input)
+}
+
+pub fn part1(input: &Grid<u8>) -> usize {
+    simulate(input, 10_000, 2)
+}
+
+pub fn part2(input: &Grid<u8>) -> usize {
+    simulate(input, 10_000_000, 1)
+}
+
+fn simulate(input: &Grid<u8>, bursts: usize, delta: usize) -> usize {
+    // Assume that the carrier will never go outside the range [0, 512] in both x and y axis.
+    // starting at the center (256, 256).
+    let full = 512;
+    let half = 256;
+    // Right, Down, Left, Up
+    let offsets = [1, full, 0_usize.wrapping_sub(1), 0_usize.wrapping_sub(full)];
+
+    // Copy input
+    let mut grid = vec![1; full * full];
+    let offset = half - (input.width / 2) as usize;
+
+    for x in 0..input.width {
+        for y in 0..input.height {
+            if input[Point::new(x, y)] == b'#' {
+                let index = full * (offset + y as usize) + (offset + x as usize);
+                grid[index] = 3; // Infected
+            }
+        }
+    }
+
+    let mut index = full * half + half; // Center
+    let mut direction = 3; // Up
+    let mut result = 0;
+
+    for _ in 0..bursts {
+        // Change state by adding either `2` for part one (flipping between clean and infected)
+        // or `1` for part two (using all four states).
+        // Clean => 1
+        // Weakened => 2
+        // Infected => 3
+        // Flagged => 0
+        let current = grid[index] as usize;
+        let next = (current + delta) & 0x3;
+        grid[index] = next as u8;
+        // Infected nodes result in a value of 4 >> 2 = 1, all other nodes result in 0.
+        result += (next + 1) >> 2;
+        // Change direction by adding an index modulo 4 depending on node type.
+        // Clean => 1 + 2 => 3 (left)
+        // Weakened => 2 + 2 => 0 (straight)
+        // Infected => 3 + 2 => 1 (right)
+        // Flagged => 0 + 2 => 2 (reverse)
+        direction = (direction + current + 2) & 0x3;
+        index = index.wrapping_add(offsets[direction]);
+    }
+
+    result
+}

Diff for: tests/test.rs

@@ -106,6 +106,7 @@ mod year2017 {
     mod day19_test;
     mod day20_test;
     mod day21_test;
+    mod day22_test;
     mod day23_test;
     mod day24_test;
     mod day25_test;

Diff for: tests/year2017/day22_test.rs

@@ -0,0 +1,18 @@
+use aoc::year2017::day22::*;
+
+const EXAMPLE: &str = "\
+..#
+#..
+...";
+
+#[test]
+fn part1_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part1(&input), 5587);
+}
+
+#[test]
+fn part2_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part2(&input), 2511944);
+}