add 2023 setup and grid code

2023/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "aoc2023"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+itertools = "0.12"
+paste = "1.0"
+
+[profile.bench]
+lto = true

2023/rustfmt.toml

@@ -0,0 +1,7 @@
+newline_style = "Unix"
+max_width = 140
+imports_granularity = "Crate"
+struct_field_align_threshold = 25
+where_single_line = true
+edition = "2021"
+use_small_heuristics = "Max"

2023/setup_day.sh

@@ -0,0 +1,34 @@
+#!/bin/sh
+
+today=$(date +%d)
+aocd > inputs/day$today
+
+echo '#![feature(test)]
+extern crate test;
+use aoc2023::{boilerplate, common::*};
+
+const DAY: usize = '$today';
+type Parsed = Vec<usize>;
+
+fn parse_input(raw: &str) -> Parsed {
+    parse_nums(raw)
+}
+
+fn part1(parsed: &Parsed) -> usize {
+    unimplemented!()
+}
+
+fn part2(parsed: &Parsed) -> usize {
+    unimplemented!()
+}
+
+boilerplate! {
+    TEST_INPUT == "",
+    tests: {
+        part1: { TEST_INPUT => 0 },
+        part2: { TEST_INPUT => 0 },
+    },
+    bench1 == 0,
+    bench2 == 0,
+    bench_parse: Vec::len => 0,
+}' > src/bin/day$today.rs

2023/src/common.rs

@@ -0,0 +1,25 @@
+pub fn read_file(day: usize) -> String {
+    std::fs::read_to_string(std::env::var("AOC_INPUT").unwrap_or_else(|_| format!("inputs/day{day:0>2}"))).unwrap()
+}
+
+pub fn parse_nums(l: &str) -> Vec<usize> {
+    l.lines().map(parse_num).collect()
+}
+
+pub fn parse_nums_comma(l: &str) -> Vec<usize> {
+    l.trim().split(',').map(parse_num).collect()
+}
+
+#[cfg(debug_assertions)]
+pub fn parse_num<T: std::str::FromStr + std::fmt::Display>(s: &str) -> T {
+    s.parse().unwrap_or_else(|_| panic!("Invalid number {s}"))
+}
+
+// For benchmarks.
+// This function assumes that the input will always be valid numbers and is UB otherwise
+#[cfg(not(debug_assertions))]
+pub fn parse_num<T: From<u8> + std::ops::Add<T, Output = T> + std::ops::Mul<T, Output = T>>(s: &str) -> T {
+    let mut digits = s.bytes().map(|b| T::from(b - b'0'));
+    let start = unsafe { digits.next().unwrap_unchecked() };
+    digits.fold(start, |acc, n| acc * T::from(10) + n)
+}

2023/src/grid.rs

@@ -0,0 +1,159 @@
+pub mod direction;
+pub mod position;
+pub use direction::*;
+use fnv::FnvHashMap as HashMap;
+use itertools::{join, Itertools, MinMaxResult};
+pub use position::*;
+use std::{
+    fmt::Display,
+    ops::{Index, IndexMut},
+};
+
+#[allow(clippy::len_without_is_empty)] // I mainly have this for assertions in benchmarks
+pub trait Grid<T, const D: usize>: Index<PositionND<D>, Output = T> + IndexMut<PositionND<D>> {
+    fn get(&self, pos: &PositionND<D>) -> Option<&T>;
+
+    fn insert<Pos: Into<PositionND<D>>>(&mut self, pos: Pos, element: T);
+
+    fn len(&self) -> usize;
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct HashGrid<T: Default, const D: usize> {
+    pub fields: HashMap<PositionND<D>, T>,
+}
+
+impl<T: Default, const D: usize> Index<PositionND<D>> for HashGrid<T, D> {
+    type Output = T;
+    fn index(&self, index: PositionND<D>) -> &Self::Output {
+        &self.fields[&index]
+    }
+}
+
+impl<T: Default, const D: usize> IndexMut<PositionND<D>> for HashGrid<T, D> {
+    fn index_mut(&mut self, index: PositionND<D>) -> &mut Self::Output {
+        self.fields.get_mut(&index).expect("Key not in map")
+    }
+}
+
+impl<T: Default, const D: usize> Grid<T, D> for HashGrid<T, D> {
+    fn get(&self, pos: &PositionND<D>) -> Option<&T> {
+        self.fields.get(pos)
+    }
+
+    fn insert<Pos: Into<PositionND<D>>>(&mut self, pos: Pos, t: T) {
+        self.fields.insert(pos.into(), t);
+    }
+
+    fn len(&self) -> usize {
+        self.fields.len()
+    }
+}
+
+impl<T: Default + Copy> HashGrid<T, 2> {
+    pub fn from_bytes_2d<F: FnMut(u8) -> T + Copy>(raw: &str, mut f: F) -> HashGrid<T, 2> {
+        raw.lines()
+            .enumerate()
+            .flat_map(move |(y, l)| l.bytes().enumerate().map(move |(x, c)| (PositionND([x as i64, y as i64]), f(c))))
+            .collect()
+    }
+}
+
+impl<T: Default, const D: usize> std::iter::FromIterator<(PositionND<D>, T)> for HashGrid<T, D> {
+    fn from_iter<I: IntoIterator<Item = (PositionND<D>, T)>>(iter: I) -> Self {
+        HashGrid { fields: iter.into_iter().collect() }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct VecGrid<T> {
+    pub fields: Vec<Vec<T>>,
+}
+
+impl<T> Grid<T, 2> for VecGrid<T> {
+    fn get(&self, pos: &PositionND<2>) -> Option<&T> {
+        self.fields.get(pos.0[0] as usize)?.get(pos.0[1] as usize)
+    }
+
+    fn insert<Pos: Into<PositionND<2>>>(&mut self, pos: Pos, element: T) {
+        let PositionND([x, y]) = pos.into();
+        self.fields[x as usize][y as usize] = element;
+    }
+
+    fn len(&self) -> usize {
+        self.fields.len()
+    }
+}
+
+impl<T> Index<Position2D> for VecGrid<T> {
+    type Output = T;
+    fn index(&self, index: Position2D) -> &Self::Output {
+        &self.fields[index.0[0] as usize][index.0[1] as usize]
+    }
+}
+
+impl<T> IndexMut<Position2D> for VecGrid<T> {
+    fn index_mut(&mut self, index: Position2D) -> &mut Self::Output {
+        &mut self.fields[index.0[0] as usize][index.0[1] as usize]
+    }
+}
+
+impl<T: Copy> VecGrid<T> {
+    pub fn from_bytes_2d<F: FnMut(u8) -> T + Copy>(raw: &str, f: F) -> VecGrid<T> {
+        VecGrid { fields: raw.lines().map(|l| l.bytes().map(f).collect()).collect() }
+    }
+}
+
+pub struct Boundaries {
+    pub x_min: i64,
+    pub x_max: i64,
+    pub y_min: i64,
+    pub y_max: i64,
+}
+
+pub fn get_boundaries(input: &[&PositionND<2>]) -> Boundaries {
+    let (x_min, x_max) = match input.iter().map(|p| p.0[0]).minmax() {
+        MinMaxResult::NoElements => (0, 0),
+        MinMaxResult::MinMax(min, max) => (min, max),
+        MinMaxResult::OneElement(x) => (x, x),
+    };
+    let (y_min, y_max) = match input.iter().map(|p| p.0[1]).minmax() {
+        MinMaxResult::NoElements => (0, 0),
+        MinMaxResult::MinMax(min, max) => (min, max),
+        MinMaxResult::OneElement(x) => (x, x),
+    };
+    Boundaries { x_min, x_max, y_min, y_max }
+}
+
+pub fn draw_ascii<T: Display + Default>(coordinates: &HashMap<PositionND<2>, T>) -> String {
+    let b = get_boundaries(&coordinates.keys().collect::<Vec<_>>());
+    join(
+        (b.x_min..=b.x_max).map(|x| {
+            (b.y_min..=b.y_max).map(|y| coordinates.get(&PositionND([x, y])).unwrap_or(&T::default()).to_string()).collect::<String>()
+        }),
+        "\n",
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_add() {
+        assert_eq!(PositionND([0, 2]) + PositionND([-1, 0]), [-1, 2].into());
+        assert_eq!(PositionND([0, -1]) + PositionND::from(Direction::Up), [0, 0].into());
+    }
+
+    #[test]
+    fn test_sub() {
+        assert_eq!(PositionND([0, 2]) - PositionND([-1, 0]), [1, 2].into());
+        assert_eq!(PositionND([0, -1]) - PositionND([0, -1]), [0, 0].into());
+    }
+
+    #[test]
+    fn test_mul() {
+        assert_eq!(PositionND([0, 2]) * 5, [0, 10].into());
+        assert_eq!(PositionND([0, -1]) * -2, [0, 2].into());
+    }
+}

2023/src/grid/direction.rs

@@ -0,0 +1,49 @@
+use impl_ops::*;
+use std::{ops, ops::AddAssign};
+
+pub const ALL_DIRECTIONS: [Direction; 4] = [Direction::Up, Direction::Down, Direction::Left, Direction::Right];
+
+#[derive(Clone, Copy, Debug)]
+pub enum Direction {
+    Right = 0,
+    Down = 1,
+    Left = 2,
+    Up = 3,
+}
+
+impl AddAssign<i8> for Direction {
+    fn add_assign(&mut self, rhs: i8) {
+        *self = *self + rhs;
+    }
+}
+
+impl_op!(+ |a: Direction, b: i8| -> Direction {
+        match b {
+            -1 | 3 => match a {
+                Direction::Up => Direction::Left,
+                Direction::Right => Direction::Up,
+                Direction::Down => Direction::Right,
+                Direction::Left => Direction::Down,
+            },
+            1 | -3 => match a {
+                Direction::Up => Direction::Right,
+                Direction::Right => Direction::Down,
+                Direction::Down => Direction::Left,
+                Direction::Left => Direction::Up,
+            },
+            0 | 4 | -4 => a,
+            2 | -2 => match a {
+                Direction::Up => Direction::Down,
+                Direction::Right => Direction::Left,
+                Direction::Down => Direction::Up,
+                Direction::Left => Direction::Right,
+            },
+            n => unreachable!("Illegal turn value: {n}"),
+        }
+});
+
+impl Direction {
+    pub fn turn(&mut self, turn_value: i64) {
+        *self += turn_value as i8;
+    }
+}

2023/src/grid/position.rs

@@ -0,0 +1,257 @@
+extern crate test;
+use super::direction::*;
+use std::{
+    convert::TryInto,
+    hash::Hash,
+    ops::{Add, Mul, Sub},
+};
+
+#[derive(Hash, PartialEq, Eq, Debug, Clone, Copy)]
+pub struct PositionND<const DIMS: usize>(pub [i64; DIMS]);
+
+pub type Position2D = PositionND<2>;
+
+impl<I, const D: usize> From<[I; D]> for PositionND<D>
+where I: TryInto<i64> + Copy
+{
+    fn from(s: [I; D]) -> Self {
+        let mut points = [0; D];
+        for i in 0..D {
+            points[i] = s[i].try_into().unwrap_or_else(|_| panic!("number did not fit in target type"))
+        }
+        Self(points)
+    }
+}
+
+pub const fn num_neighbors(d: usize) -> usize {
+    3usize.pow(d as u32) - 1
+}
+
+impl<const DIMS: usize> PositionND<DIMS> {
+    pub const fn zero() -> Self {
+        PositionND([0; DIMS])
+    }
+
+    pub fn from_padded(slice: &[i64]) -> PositionND<DIMS> {
+        let mut points = [0; DIMS];
+        #[allow(clippy::manual_memcpy)]
+        for i in 0..(DIMS.min(slice.len())) {
+            points[i] = slice[i];
+        }
+        PositionND(points)
+    }
+
+    pub fn neighbors(&self) -> [PositionND<DIMS>; num_neighbors(DIMS)]
+    where [PositionND<DIMS>; num_neighbors(DIMS) + 1]: Sized {
+        let ns = neighbor_vectors::<DIMS>();
+        let mut out = [*self; num_neighbors(DIMS)];
+        for (out, dir) in out.iter_mut().zip(IntoIterator::into_iter(ns).filter(|n| n != &[0; DIMS])) {
+            *out = *out + PositionND::from(dir);
+        }
+        out
+    }
+}
+
+impl PositionND<2> {
+    pub fn neighbors_no_diagonals_only_positive(&self) -> [PositionND<2>; 2] {
+        let PositionND::<2>([x, y]) = *self;
+        [[x + 1, y].into(), [x, y + 1].into()]
+    }
+
+    pub fn neighbors_no_diagonals(&self) -> [PositionND<2>; 4] {
+        let PositionND::<2>([x, y]) = *self;
+        [[x + 1, y].into(), [x, y + 1].into(), [x - 1, y].into(), [x, y - 1].into()]
+    }
+}
+
+#[macro_export]
+macro_rules! dim {
+    ($d: expr) => {{
+        let mut out = [[0; D]; num_neighbors(D) + 1];
+        let mut i = 0;
+        for offset in -1..=1 {
+            for inner in neighbor_vectors::<$d>() {
+                out[i][0] = offset;
+                let mut j = 1;
+                for e in inner {
+                    out[i][j] = e;
+                    j += 1;
+                }
+                i += 1;
+            }
+        }
+        out
+    }};
+}
+
+fn neighbor_vectors<const D: usize>() -> [[i64; D]; num_neighbors(D) + 1]
+where
+{
+    // I would love to just call neighbor_vectors::<D-1>(), but it seems to be impossible to get the
+    // correct constraints for that.
+    match D {
+        0 => unreachable!(),
+        1 => {
+            let mut out = [[0; D]; num_neighbors(D) + 1];
+            out[0] = [-1; D];
+            out[1] = [0; D];
+            out[2] = [1; D];
+            out
+        }
+        2 => dim!(1),
+        3 => dim!(2),
+        4 => dim!(3),
+        5 => dim!(4),
+        6 => dim!(5),
+        7 => dim!(6),
+        // Adding more causes a stackoverflow. How curious.
+        _ => unimplemented!(),
+    }
+}
+
+impl<const D: usize> Mul<i64> for PositionND<D> {
+    type Output = PositionND<D>;
+
+    fn mul(mut self, rhs: i64) -> Self::Output {
+        for p in self.0.iter_mut() {
+            *p *= rhs;
+        }
+        self
+    }
+}
+
+impl<const D: usize> Add<PositionND<D>> for PositionND<D> {
+    type Output = PositionND<D>;
+
+    fn add(mut self, rhs: PositionND<D>) -> Self::Output {
+        for (x, y) in self.0.iter_mut().zip(rhs.0) {
+            *x += y;
+        }
+        self
+    }
+}
+
+impl<const D: usize> Sub<PositionND<D>> for PositionND<D> {
+    type Output = PositionND<D>;
+
+    fn sub(mut self, rhs: PositionND<D>) -> Self::Output {
+        for (x, y) in self.0.iter_mut().zip(rhs.0) {
+            *x -= y;
+        }
+        self
+    }
+}
+
+impl From<Direction> for PositionND<2> {
+    fn from(d: Direction) -> Self {
+        match d {
+            Direction::Up => PositionND::from([0, 1]),
+            Direction::Right => PositionND::from([1, 0]),
+            Direction::Left => PositionND::from([-1, 0]),
+            Direction::Down => PositionND::from([0, -1]),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_neighbors_2d() {
+        let p = PositionND([0, 0]);
+        let n = p.neighbors();
+        assert_eq!(
+            n,
+            [
+                PositionND([-1, -1]),
+                PositionND([-1, 0]),
+                PositionND([-1, 1]),
+                PositionND([0, -1]),
+                PositionND([0, 1]),
+                PositionND([1, -1]),
+                PositionND([1, 0]),
+                PositionND([1, 1]),
+            ]
+        );
+
+        let p = PositionND([1, 1]);
+        let n = p.neighbors();
+        assert_eq!(
+            n,
+            [
+                PositionND([0, 0]),
+                PositionND([0, 1]),
+                PositionND([0, 2]),
+                PositionND([1, 0]),
+                PositionND([1, 2]),
+                PositionND([2, 0]),
+                PositionND([2, 1]),
+                PositionND([2, 2]),
+            ]
+        )
+    }
+
+    #[test]
+    fn test_neighbors_3d() {
+        let p = PositionND([0, 0, 0]);
+        let n = p.neighbors();
+        assert_eq!(
+            n,
+            [
+                PositionND([-1, -1, -1]),
+                PositionND([-1, -1, 0]),
+                PositionND([-1, -1, 1]),
+                PositionND([-1, 0, -1]),
+                PositionND([-1, 0, 0]),
+                PositionND([-1, 0, 1]),
+                PositionND([-1, 1, -1]),
+                PositionND([-1, 1, 0]),
+                PositionND([-1, 1, 1]),
+                PositionND([0, -1, -1]),
+                PositionND([0, -1, 0]),
+                PositionND([0, -1, 1]),
+                PositionND([0, 0, -1]),
+                PositionND([0, 0, 1]),
+                PositionND([0, 1, -1]),
+                PositionND([0, 1, 0]),
+                PositionND([0, 1, 1]),
+                PositionND([1, -1, -1]),
+                PositionND([1, -1, 0]),
+                PositionND([1, -1, 1]),
+                PositionND([1, 0, -1]),
+                PositionND([1, 0, 0]),
+                PositionND([1, 0, 1]),
+                PositionND([1, 1, -1]),
+                PositionND([1, 1, 0]),
+                PositionND([1, 1, 1]),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_neighbor_vectors() {
+        let n = neighbor_vectors::<2>();
+        assert_eq!(n, [[-1, -1], [-1, 0], [-1, 1], [0, -1], [0, 0], [0, 1], [1, -1], [1, 0], [1, 1],]);
+    }
+
+    #[bench]
+    fn bench_neighbor_vectors_2d(b: &mut test::Bencher) {
+        b.iter(|| test::black_box(neighbor_vectors::<2>()))
+    }
+
+    #[bench]
+    fn bench_neighbor_vectors_3d(b: &mut test::Bencher) {
+        b.iter(|| test::black_box(neighbor_vectors::<3>()))
+    }
+
+    #[bench]
+    fn bench_neighbor_vectors_4d(b: &mut test::Bencher) {
+        b.iter(|| test::black_box(neighbor_vectors::<4>()))
+    }
+
+    #[bench]
+    fn bench_neighbor_vectors_5d(b: &mut test::Bencher) {
+        b.iter(|| test::black_box(neighbor_vectors::<5>()))
+    }
+}

2023/src/lib.rs

@@ -0,0 +1,5 @@
+#![allow(incomplete_features)]
+#![feature(test, generic_const_exprs)]
+pub mod common;
+pub mod grid;
+pub mod teststuff;

2023/src/teststuff.rs

@@ -0,0 +1,65 @@
+#[macro_export]
+macro_rules! boilerplate {
+    (
+        TEST_INPUT == $ti: literal,
+        tests: {
+            $($part: ident: { $($tpi: expr $(,$ati: expr)* => $to: expr),+$(,)? }),*$(,)?
+        },
+        $(unittests: {
+            $($unittest: ident: { $($($utpi: expr),+ => $uto: expr),+$(,)? }),*$(,)?
+        },)?
+        bench1$(($bi1: literal))? == $b1: literal,
+        bench2$(($bi2: literal))? == $b2: literal,
+        bench_parse: $input_fn: expr => $it: expr$(,)?
+    ) => {
+    fn main() {
+        let raw_input = read_file(DAY);
+        let input = parse_input(&raw_input);
+        println!("Part 1: {}", part1(&input$(,$bi1)?));
+        println!("Part 2: {}", part2(&input$(,$bi2)?));
+    }
+
+    #[cfg(test)]
+    mod tests {
+        use super::*;
+        use aoc2023::*;
+
+        const TEST_INPUT: &str = $ti;
+
+        $($($(paste::paste! {
+            #[test]
+            fn [<$unittest _test_ $uto:lower>]() {
+                assert_eq!($unittest($($utpi),+), $uto);
+            }
+        })+)*)?
+        $($(paste::paste! {
+            #[test]
+            fn [<$part _test_ $to:lower>]() {
+                let input = parse_input($tpi);
+                assert_eq!($part(&input, $($ati),*), $to);
+            }
+        })+)*
+        bench!(part1($($bi1)?) == $b1);
+        bench!(part2($($bi2)?) == $b2);
+        #[bench]
+        fn bench_input_parsing(b: &mut test::Bencher) {
+            let raw = &read_file(DAY);
+            b.iter(|| assert_eq!($input_fn(&parse_input(test::black_box(&raw))), $it));
+        }
+    }
+    }
+}
+
+#[macro_export]
+macro_rules! bench {
+    ($part: ident($($bi: literal)?) == $expected:expr) => {
+        paste::paste! {
+            #[bench]
+            fn [<$part _bench>](b: &mut test::Bencher) {
+                let raw = &read_file(DAY);
+                let input = parse_input(&raw);
+                b.iter(|| assert_eq!($part(test::black_box(&input)$(, $bi)?), $expected));
+            }
+        }
+    };
+}