changes from previous years

Author: majcn

.github/workflows/ci.yml

@@ -25,9 +25,7 @@ jobs:
                 restore-keys: ${{ runner.os }}-cargo-
             - name: cargo test
               run: cargo test
-            # uncomment to enable clippy linter
-            # - name: cargo clippy
-            #   run: cargo clippy -- -D warnings
-            # uncomment to enable format linter
-            # - name: cargo fmt
-            #   run: cargo fmt --check
+            - name: cargo clippy
+              run: cargo clippy -- -D warnings
+            - name: cargo fmt
+              run: cargo fmt --check

Cargo.lock

@@ -28,3 +28,4 @@ pico-args = "0.5.0"
 tinyjson = "2.5.1"
 
 # Solution dependencies
+fastrand = "2.0.1"

Cargo.toml

@@ -1,6 +1,6 @@
 <img src="./.assets/christmas_ferris.png" width="164">
 
-# 🎄 Advent of Code {year}
+# 🎄 Advent of Code 2024
 
 Solutions for [Advent of Code](https://adventofcode.com/) in [Rust](https://www.rust-lang.org/).
 
@@ -230,7 +230,7 @@ To enable it, complete the following steps:
 
 #### 1. Create a private leaderboard
 
-Go to the leaderboard page of the year you want to track and click _Private Leaderboard_. If you have not created a leaderboard yet, create one by clicking _Create It_. Your leaderboard should be accessible under `https://adventofcode.com/{year}/leaderboard/private/view/{aoc_user_id}`.
+Go to the leaderboard page of the year you want to track and click _Private Leaderboard_. If you have not created a leaderboard yet, create one by clicking _Create It_. Your leaderboard should be accessible under `https://adventofcode.com/2024/leaderboard/private/view/{aoc_user_id}`.
 
 #### 2. Set repository secrets
 

README.md

@@ -1,3 +1,5 @@
 pub mod template;
 
 // Use this file to add helper functions and additional modules.
+pub mod majcn;
+pub mod maneatingape;

src/lib.rs

@@ -0,0 +1,95 @@
+#[derive(Clone, Copy)]
+pub struct UX64<const N: usize>([u64; N]);
+
+impl<const N: usize> UX64<N> {
+    pub fn count_ones(&self) -> u32 {
+        self.0.iter().map(|x| x.count_ones()).sum()
+    }
+
+    pub const ZERO: UX64<N> = UX64([0; N]);
+    pub const ONE: UX64<N> = {
+        let mut result = UX64([0; N]);
+        result.0[0] = 1;
+        result
+    };
+}
+
+impl<const N: usize> std::ops::Shl<usize> for UX64<N> {
+    type Output = UX64<N>;
+
+    fn shl(self, rhs: usize) -> Self::Output {
+        let mut result = UX64::ZERO;
+        let word_shift = rhs / 64;
+        let bit_shift = rhs % 64;
+        for i in 0..N {
+            if bit_shift < 64 && i + word_shift < N {
+                result.0[i + word_shift] += self.0[i] << bit_shift;
+            }
+            if bit_shift > 0 && i + word_shift + 1 < N {
+                result.0[i + word_shift + 1] += self.0[i] >> (64 - bit_shift);
+            }
+        }
+        result
+    }
+}
+
+impl<const N: usize> std::ops::Shr<usize> for UX64<N> {
+    type Output = UX64<N>;
+
+    fn shr(self, shift: usize) -> Self::Output {
+        let mut result = UX64::ZERO;
+        let word_shift = shift / 64;
+        let bit_shift = shift % 64;
+        for i in word_shift..N {
+            result.0[i - word_shift] += self.0[i] >> bit_shift;
+            if bit_shift > 0 && i < N - 1 {
+                result.0[i - word_shift] += self.0[i + 1] << (64 - bit_shift);
+            }
+        }
+        result
+    }
+}
+
+impl<const N: usize> std::ops::BitAnd for UX64<N> {
+    type Output = UX64<N>;
+
+    fn bitand(self, rhs: Self) -> Self::Output {
+        let mut result = UX64::ZERO;
+        for i in 0..N {
+            result.0[i] = self.0[i] & rhs.0[i];
+        }
+        result
+    }
+}
+
+impl<const N: usize> std::ops::BitOr for UX64<N> {
+    type Output = UX64<N>;
+
+    fn bitor(self, rhs: Self) -> Self::Output {
+        let mut result = UX64::ZERO;
+        for i in 0..N {
+            result.0[i] = self.0[i] | rhs.0[i];
+        }
+        result
+    }
+}
+
+impl<const N: usize> std::ops::BitOrAssign for UX64<N> {
+    fn bitor_assign(&mut self, rhs: Self) {
+        for i in 0..N {
+            self.0[i] = self.0[i] | rhs.0[i];
+        }
+    }
+}
+
+impl<const N: usize> std::ops::Not for UX64<N> {
+    type Output = UX64<N>;
+
+    fn not(self) -> Self::Output {
+        let mut result = UX64::ZERO;
+        for i in 0..N {
+            result.0[i] = !self.0[i];
+        }
+        result
+    }
+}

src/majcn/bignumbers.rs

@@ -0,0 +1 @@
+pub mod bignumbers;

src/majcn/mod.rs

@@ -0,0 +1,21 @@
+# MIT License
+
+**Copyright © 2023 maneatingape**
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

src/maneatingape/LICENSE.md

@@ -0,0 +1,92 @@
+// source: https://github.com/maneatingape/advent-of-code-rust/blob/72c8feb22030d55d7a08f16c119425b2ba759470/src/util/hash.rs
+
+//! Fast 2 dimensional Grid backed by a single `vec`. This module is designed to work with [`Point`].
+//!
+//! The traits [`Index`] and [`IndexMut`] are implemented for [`Point`] to allow usage like:
+//!
+//! ```
+//!   # use aoc::util::grid::Grid;
+//!   # use aoc::util::point::Point;
+//!
+//!   let mut grid = Grid::parse("1");
+//!   let point = Point::new(0, 0);
+//!
+//!   let foo = grid[point];
+//!   assert_eq!(foo, b'1');
+//!
+//!   grid[point] = foo + 1;
+//!   assert_eq!(grid[point], b'2');
+//! ```
+//!
+//! A convenience [`parse`] method creates a `Grid` directly from a 2 dimenionsal set of
+//! ASCII characters, a common occurence in Advent of Code inputs. The [`default_copy`] function
+//! creates a grid of the same size, that can be used for in BFS algorithms for tracking visited
+//! location or for tracking cost in Djikstra.
+//!
+//! [`Point`]: crate::util::point
+//! [`parse`]: Grid::parse
+//! [`default_copy`]: Grid::default_copy
+use crate::maneatingape::point::*;
+use std::ops::{Index, IndexMut};
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct Grid<T> {
+    pub width: i32,
+    pub height: i32,
+    pub bytes: Vec<T>,
+}
+
+impl Grid<u8> {
+    pub fn parse(input: &str) -> Self {
+        let raw: Vec<_> = input.lines().map(str::as_bytes).collect();
+        let width = raw[0].len() as i32;
+        let height = raw.len() as i32;
+        let mut bytes = Vec::with_capacity((width * height) as usize);
+        raw.iter().for_each(|slice| bytes.extend_from_slice(slice));
+        Grid {
+            width,
+            height,
+            bytes,
+        }
+    }
+}
+
+impl<T: Copy + PartialEq> Grid<T> {
+    pub fn default_copy<U: Default + Copy>(&self) -> Grid<U> {
+        Grid {
+            width: self.width,
+            height: self.height,
+            bytes: vec![U::default(); (self.width * self.height) as usize],
+        }
+    }
+
+    pub fn find(&self, needle: T) -> Option<Point> {
+        let to_point = |index| {
+            let x = (index as i32) % self.width;
+            let y = (index as i32) / self.width;
+            Point::new(x, y)
+        };
+        self.bytes.iter().position(|&h| h == needle).map(to_point)
+    }
+
+    #[inline]
+    pub fn contains(&self, point: Point) -> bool {
+        point.x >= 0 && point.x < self.width && point.y >= 0 && point.y < self.height
+    }
+}
+
+impl<T> Index<Point> for Grid<T> {
+    type Output = T;
+
+    #[inline]
+    fn index(&self, point: Point) -> &Self::Output {
+        &self.bytes[(self.width * point.y + point.x) as usize]
+    }
+}
+
+impl<T> IndexMut<Point> for Grid<T> {
+    #[inline]
+    fn index_mut(&mut self, point: Point) -> &mut Self::Output {
+        &mut self.bytes[(self.width * point.y + point.x) as usize]
+    }
+}