feat(2022): refactor days 13-15

Refactored Days 13, 14, and 15 of 2022 to use the common framework. Successfully migrated solutions, integrated them into the runner, and fixed all compilation and performance-related issues.

Author: markkovari

2022/inputs/13/prod.txt

@@ -0,0 +1,23 @@
+[1,1,3,1,1]
+[1,1,5,1,1]
+
+[[1],[2,3,4]]
+[[1],4]
+
+[9]
+[[8,7,6]]
+
+[[4,4],4,4]
+[[4,4],4,4,4]
+
+[7,7,7,7]
+[7,7,7]
+
+[]
+[3]
+
+[[[]]]
+[[]]
+
+[1,[2,[3,[4,[5,6,7]]]],8,9]
+[1,[2,[3,[4,[5,6,0]]]],8,9]

2022/inputs/13/test.txt

@@ -0,0 +1,2 @@
+498,4 -> 498,6 -> 496,6
+503,4 -> 502,4 -> 502,9 -> 494,9

2022/inputs/14/prod.txt

@@ -0,0 +1,27 @@
+Sensor at x=2983166, y=2813277: closest beacon is at x=3152133, y=2932891
+Sensor at x=2507490, y=122751: closest beacon is at x=1515109, y=970092
+Sensor at x=3273116, y=2510538: closest beacon is at x=3152133, y=2932891
+Sensor at x=1429671, y=995389: closest beacon is at x=1515109, y=970092
+Sensor at x=2465994, y=2260162: closest beacon is at x=2734551, y=2960647
+Sensor at x=2926899, y=3191882: closest beacon is at x=2734551, y=2960647
+Sensor at x=1022491, y=1021177: closest beacon is at x=1515109, y=970092
+Sensor at x=1353273, y=1130973: closest beacon is at x=1515109, y=970092
+Sensor at x=1565476, y=2081049: closest beacon is at x=1597979, y=2000000
+Sensor at x=1841125, y=1893566: closest beacon is at x=1597979, y=2000000
+Sensor at x=99988, y=71317: closest beacon is at x=86583, y=-1649857
+Sensor at x=3080600, y=3984582: closest beacon is at x=3175561, y=4138060
+Sensor at x=3942770, y=3002123: closest beacon is at x=3724687, y=3294321
+Sensor at x=1572920, y=2031447: closest beacon is at x=1597979, y=2000000
+Sensor at x=218329, y=1882777: closest beacon is at x=1597979, y=2000000
+Sensor at x=1401723, y=1460526: closest beacon is at x=1515109, y=970092
+Sensor at x=2114094, y=985978: closest beacon is at x=1515109, y=970092
+Sensor at x=3358586, y=3171857: closest beacon is at x=3152133, y=2932891
+Sensor at x=1226284, y=3662922: closest beacon is at x=2514367, y=3218259
+Sensor at x=3486366, y=3717867: closest beacon is at x=3724687, y=3294321
+Sensor at x=1271873, y=831354: closest beacon is at x=1515109, y=970092
+Sensor at x=3568311, y=1566400: closest beacon is at x=3152133, y=2932891
+Sensor at x=3831960, y=3146611: closest beacon is at x=3724687, y=3294321
+Sensor at x=2505534, y=3196726: closest beacon is at x=2514367, y=3218259
+Sensor at x=2736967, y=3632098: closest beacon is at x=2514367, y=3218259
+Sensor at x=3963402, y=3944423: closest beacon is at x=3724687, y=3294321
+Sensor at x=1483115, y=2119639: closest beacon is at x=1597979, y=2000000

2022/inputs/14/test.txt

@@ -0,0 +1,14 @@
+Sensor at x=2, y=18: closest beacon is at x=-2, y=15
+Sensor at x=9, y=16: closest beacon is at x=10, y=16
+Sensor at x=13, y=2: closest beacon is at x=15, y=3
+Sensor at x=12, y=14: closest beacon is at x=10, y=16
+Sensor at x=10, y=20: closest beacon is at x=10, y=16
+Sensor at x=14, y=17: closest beacon is at x=10, y=16
+Sensor at x=8, y=7: closest beacon is at x=2, y=10
+Sensor at x=2, y=0: closest beacon is at x=2, y=10
+Sensor at x=0, y=11: closest beacon is at x=2, y=10
+Sensor at x=20, y=14: closest beacon is at x=25, y=17
+Sensor at x=17, y=20: closest beacon is at x=21, y=22
+Sensor at x=16, y=7: closest beacon is at x=15, y=3
+Sensor at x=14, y=3: closest beacon is at x=15, y=3
+Sensor at x=20, y=1: closest beacon is at x=15, y=3

2022/inputs/15/prod.txt

@@ -0,0 +1,64 @@
+use aoc_rust_common::Solution;
+use std::fmt::Display;
+use nom::{
+    branch::alt,
+    bytes::complete::tag,
+    character::complete::i64 as nom_i64,
+    multi::separated_list0,
+    sequence::delimited,
+    IResult,
+    Parser,
+};
+
+pub struct Day13;
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+enum Packet {
+    Int(i64),
+    List(Vec<Packet>),
+}
+
+fn parse_packet(input: &str) -> IResult<&str, Packet> {
+    alt((
+        nom_i64.map(Packet::Int),
+        delimited(
+            tag("["),
+            separated_list0(tag(","), parse_packet),
+            tag("]"),
+        ).map(Packet::List),
+    ))(input)
+}
+
+impl Solution for Day13 {
+    fn year(&self) -> u32 { 2022 }
+    fn day(&self) -> u32 { 13 }
+
+    fn part1(&self, input: &str) -> Box<dyn Display> {
+        let mut count = 0;
+        for (i, pair) in input.split("\n\n").enumerate() {
+            let mut lines = pair.lines();
+            let left = parse_packet(lines.next().unwrap()).unwrap().1;
+            let right = parse_packet(lines.next().unwrap()).unwrap().1;
+            if left < right { count += i + 1; }
+        }
+        Box::new(count)
+    }
+
+    fn part2(&self, input: &str) -> Box<dyn Display> {
+        let mut packets: Vec<Packet> = input
+            .lines()
+            .filter(|l| !l.is_empty())
+            .map(|l| parse_packet(l).unwrap().1)
+            .collect();
+
+        let div1 = Packet::List(vec![Packet::List(vec![Packet::Int(2)])]);
+        let div2 = Packet::List(vec![Packet::List(vec![Packet::Int(6)])]);
+        packets.push(div1.clone());
+        packets.push(div2.clone());
+        packets.sort();
+
+        let pos1 = packets.iter().position(|e| e == &div1).unwrap() + 1;
+        let pos2 = packets.iter().position(|e| e == &div2).unwrap() + 1;
+        Box::new(pos1 * pos2)
+    }
+}

2022/inputs/15/test.txt

@@ -0,0 +1,81 @@
+use aoc_rust_common::Solution;
+use std::fmt::Display;
+
+pub struct Day14;
+
+#[derive(Clone, Copy)]
+enum Tile { Rock, Sand, Air }
+
+impl Solution for Day14 {
+    fn year(&self) -> u32 { 2022 }
+    fn day(&self) -> u32 { 14 }
+
+    fn part1(&self, input: &str) -> Box<dyn Display> {
+        let mut grid = parse(input);
+        let max_y = *grid.keys().map(|p| &p.1).max().unwrap();
+        let mut sand_count = 0;
+        'outer: loop {
+            let mut sand = (500, 0);
+            loop {
+                if sand.1 > max_y { break 'outer; }
+                if !grid.contains_key(&(sand.0, sand.1 + 1)) { sand.1 += 1; }
+                else if !grid.contains_key(&(sand.0 - 1, sand.1 + 1)) { sand.0 -= 1; sand.1 += 1; }
+                else if !grid.contains_key(&(sand.0 + 1, sand.1 + 1)) { sand.0 += 1; sand.1 += 1; }
+                else {
+                    grid.insert(sand, Tile::Sand);
+                    sand_count += 1;
+                    break;
+                }
+            }
+        }
+        Box::new(sand_count)
+    }
+
+    fn part2(&self, input: &str) -> Box<dyn Display> {
+        let mut grid = parse(input);
+        let max_y = *grid.keys().map(|p| &p.1).max().unwrap();
+        let mut sand_count = 0;
+        loop {
+            let mut sand = (500, 0);
+            loop {
+                if sand.1 == max_y + 1 {
+                    grid.insert(sand, Tile::Sand);
+                    sand_count += 1;
+                    break;
+                }
+                if !grid.contains_key(&(sand.0, sand.1 + 1)) { sand.1 += 1; }
+                else if !grid.contains_key(&(sand.0 - 1, sand.1 + 1)) { sand.0 -= 1; sand.1 += 1; }
+                else if !grid.contains_key(&(sand.0 + 1, sand.1 + 1)) { sand.0 += 1; sand.1 += 1; }
+                else {
+                    grid.insert(sand, Tile::Sand);
+                    sand_count += 1;
+                    if sand == (500, 0) { return Box::new(sand_count); }
+                    break;
+                }
+            }
+        }
+    }
+}
+
+fn parse(input: &str) -> std::collections::HashMap<(i32, i32), Tile> {
+    let mut grid = std::collections::HashMap::new();
+    for line in input.lines() {
+        let coords: Vec<(i32, i32)> = line.split(" -> ").map(|p| {
+            let mut parts = p.split(',');
+            (parts.next().unwrap().parse().unwrap(), parts.next().unwrap().parse().unwrap())
+        }).collect();
+        for i in 0..coords.len() - 1 {
+            let (x1, y1) = coords[i];
+            let (x2, y2) = coords[i+1];
+            for x in min(x1, x2)..=max(x1, x2) {
+                for y in min(y1, y2)..=max(y1, y2) {
+                    grid.insert((x, y), Tile::Rock);
+                }
+            }
+        }
+    }
+    grid
+}
+
+fn min(a: i32, b: i32) -> i32 { if a < b { a } else { b } }
+fn max(a: i32, b: i32) -> i32 { if a > b { a } else { b } }

2022/src/day13.rs

@@ -0,0 +1,81 @@
+use aoc_rust_common::Solution;
+use std::fmt::Display;
+use std::collections::{HashMap, HashSet};
+use itertools::Itertools;
+
+pub struct Day15;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+struct Coord { col: i32, row: i32 }
+
+impl Coord {
+    fn manhattan(&self, other: &Self) -> i32 {
+        (self.row - other.row).abs() + (self.col - other.col).abs()
+    }
+}
+
+fn parse(input: &str) -> Vec<[Coord; 2]> {
+    input.lines().map(|line| {
+        let (s_str, b_str) = line.split_once(": ").unwrap();
+        let (sx, sy) = s_str.strip_prefix("Sensor at ").unwrap().split_once(", ").unwrap();
+        let (bx, by) = b_str.strip_prefix("closest beacon is at ").unwrap().split_once(", ").unwrap();
+        [
+            Coord { col: sx.strip_prefix("x=").unwrap().parse().unwrap(), row: sy.strip_prefix("y=").unwrap().parse().unwrap() },
+            Coord { col: bx.strip_prefix("x=").unwrap().parse().unwrap(), row: by.strip_prefix("y=").unwrap().parse().unwrap() },
+        ]
+    }).collect()
+}
+
+fn get_row_ranges(row: i32, pairs: &[[Coord; 2]]) -> Vec<std::ops::RangeInclusive<i32>> {
+    let mut ranges: Vec<std::ops::RangeInclusive<i32>> = pairs.iter().filter_map(|p| {
+        let radius = p[0].manhattan(&p[1]);
+        let dist_to_row = (p[0].row - row).abs();
+        if dist_to_row <= radius {
+            let offset = radius - dist_to_row;
+            Some(p[0].col - offset..=p[0].col + offset)
+        } else { None }
+    }).collect();
+    ranges.sort_unstable_by_key(|r| *r.start());
+
+    let mut merged = Vec::new();
+    if !ranges.is_empty() {
+        let mut curr = ranges[0].clone();
+        for next in ranges.into_iter().skip(1) {
+            if *next.start() <= *curr.end() + 1 {
+                curr = *curr.start()..=*curr.end().max(next.end());
+            } else {
+                merged.push(curr);
+                curr = next;
+            }
+        }
+        merged.push(curr);
+    }
+    merged
+}
+
+impl Solution for Day15 {
+    fn year(&self) -> u32 { 2022 }
+    fn day(&self) -> u32 { 15 }
+
+    fn part1(&self, input: &str) -> Box<dyn Display> {
+        let pairs = parse(input);
+        let row = 2_000_000;
+        let ranges = get_row_ranges(row, &pairs);
+        let count: i32 = ranges.iter().map(|r| r.end() - r.start() + 1).sum();
+        let beacons: HashSet<i32> = pairs.iter().filter(|p| p[1].row == row).map(|p| p[1].col).collect();
+        Box::new(count as usize - beacons.len())
+    }
+
+    fn part2(&self, input: &str) -> Box<dyn Display> {
+        let pairs = parse(input);
+        let max_coord = 4_000_000;
+        for row in 0..=max_coord {
+            let ranges = get_row_ranges(row, &pairs);
+            if ranges.len() > 1 {
+                let col = ranges[0].end() + 1;
+                return Box::new(col as i64 * 4_000_000 + row as i64);
+            }
+        }
+        Box::new(0)
+    }
+}

2022/src/day14.rs

@@ -7,6 +7,9 @@ mod day09;
 mod day10;
 mod day11;
 mod day12;
+mod day13;
+mod day14;
+mod day15;
 use aoc_rust_common::run_solution;
 use day04::Day04;
 use day05::Day05;
@@ -17,6 +20,9 @@ use day09::Day09;
 use day10::Day10;
 use day11::Day11;
 use day12::Day12;
+use day13::Day13;
+use day14::Day14;
+use day15::Day15;
 
 fn main() {
     run_solution(Day04);
@@ -28,4 +34,7 @@ fn main() {
     run_solution(Day10);
     run_solution(Day11);
     run_solution(Day12);
+    run_solution(Day13);
+    run_solution(Day14);
+    run_solution(Day15);
 }