Add template

michel-kraemer · michel-kraemer · commit 6953c2da484e · 2024-12-15T16:50:31.000+01:00
diff --git a/template/.vscode/settings.json b/template/.vscode/settings.json
@@ -0,0 +1,7 @@
+{
+  "[rust]": {
+    "editor.defaultFormatter": "rust-lang.rust-analyzer",
+    "editor.formatOnSave": true
+  },
+  "rust-analyzer.check.command": "clippy"
+}
diff --git a/template/Cargo.lock b/template/Cargo.lock
diff --git a/template/Cargo.toml b/template/Cargo.toml
@@ -0,0 +1,4 @@
+[package]
+name = "day01"
+version = "0.1.0"
+edition = "2021"
diff --git a/template/input1.txt b/template/input1.txt
diff --git a/template/src/grid.rs b/template/src/grid.rs
@@ -0,0 +1,131 @@
+#![allow(unused)]
+use std::{
+    char,
+    fmt::{Display, Formatter},
+    fs,
+    ops::{Index, Range},
+};
+
+pub const DIRS: [(i64, i64); 4] = [(1, 0), (-1, 0), (0, 1), (0, -1)];
+pub const CLOCKWISE: [(i64, i64); 8] = [
+    (1, 0),
+    (1, 1),
+    (0, 1),
+    (-1, 1),
+    (-1, 0),
+    (-1, -1),
+    (0, -1),
+    (1, -1),
+];
+
+pub trait ReadToGrid {
+    fn read_to_grid(&self) -> Grid<char>;
+}
+
+pub fn read_to_grid(filename: &str) -> Result<Grid<char>, std::io::Error> {
+    let g = fs::read_to_string(filename)?
+        .lines()
+        .map(|l| l.chars().collect())
+        .collect();
+    Ok(Grid { grid: g })
+}
+
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
+pub struct Grid<T: Copy> {
+    pub grid: Vec<Vec<T>>,
+}
+
+impl<T: Copy> Grid<T> {
+    #[inline]
+    pub fn has(&self, x: i64, y: i64) -> bool {
+        x >= 0 && x < self.width() && y >= 0 && y < self.height()
+    }
+
+    #[inline]
+    pub fn width(&self) -> i64 {
+        self.grid[0].len() as i64
+    }
+
+    #[inline]
+    pub fn height(&self) -> i64 {
+        self.grid.len() as i64
+    }
+
+    #[inline]
+    pub fn len(&self) -> i64 {
+        self.width() * self.height()
+    }
+
+    #[inline]
+    pub fn get(&self, x: i64, y: i64) -> T {
+        self.grid[y as usize][x as usize]
+    }
+
+    #[inline]
+    pub fn set(&mut self, x: i64, y: i64, c: T) {
+        self.grid[y as usize][x as usize] = c;
+    }
+
+    #[inline]
+    pub fn row_range(&self) -> Range<i64> {
+        0..self.height()
+    }
+
+    #[inline]
+    pub fn col_range(&self) -> Range<i64> {
+        0..self.width()
+    }
+
+    pub fn iter(&self) -> GridIterator<T> {
+        GridIterator {
+            grid: self,
+            x: 0,
+            y: 0,
+        }
+    }
+}
+
+pub struct GridIterator<'a, T: Copy> {
+    grid: &'a Grid<T>,
+    x: i64,
+    y: i64,
+}
+
+impl<'a, T: Copy> Iterator for GridIterator<'a, T> {
+    type Item = (i64, i64, T);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.y >= self.grid.height() {
+            return None;
+        }
+
+        let c = self.grid.get(self.x, self.y);
+        let r = (self.x, self.y, c);
+        self.x += 1;
+        if self.x >= self.grid.width() {
+            self.x = 0;
+            self.y += 1;
+        }
+        Some(r)
+    }
+}
+
+impl<T: Copy> Index<(i64, i64)> for Grid<T> {
+    type Output = T;
+
+    fn index(&self, (x, y): (i64, i64)) -> &Self::Output {
+        &self.grid[y as usize][x as usize]
+    }
+}
+
+impl<T: Copy + Display> Display for Grid<T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), core::fmt::Error> {
+        for row in self.grid.iter() {
+            for c in row.iter() {
+                write!(f, "{}", c)?;
+            }
+            writeln!(f)?;
+        }
+        Ok(())
+    }
+}
diff --git a/template/src/main.rs b/template/src/main.rs
@@ -0,0 +1,14 @@
+#![allow(unused)]
+use grid::*;
+use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
+use std::fs;
+use util::*;
+
+mod grid;
+mod util;
+
+fn main() {
+    let input = fs::read_to_string("input.txt").expect("Could not read file");
+    let lines = input.lines().collect::<Vec<_>>();
+    // let grid = grid::read_to_grid("input.txt").expect("Could not read file");
+}
diff --git a/template/src/util.rs b/template/src/util.rs
@@ -0,0 +1,108 @@
+#![allow(unused)]
+
+pub fn uints(s: &str) -> Vec<u64> {
+    let mut result = Vec::new();
+    let bytes = s.as_bytes();
+    let mut i = 0;
+    while i < bytes.len() {
+        while i < bytes.len() && !bytes[i].is_ascii_digit() {
+            i += 1;
+        }
+        if i == bytes.len() {
+            break;
+        }
+        let mut n = 0u64;
+        while i < bytes.len() && bytes[i].is_ascii_digit() {
+            n *= 10;
+            n += (bytes[i] - b'0') as u64;
+            i += 1;
+        }
+        result.push(n);
+    }
+    result
+}
+
+pub fn iints(s: &str) -> Vec<i64> {
+    let mut result = Vec::new();
+    let bytes = s.as_bytes();
+    let mut i = 0;
+    while i < bytes.len() {
+        while i < bytes.len()
+            && !bytes[i].is_ascii_digit()
+            && !(i < bytes.len() - 1 && bytes[i] == b'-' && bytes[i + 1].is_ascii_digit())
+        {
+            i += 1;
+        }
+        if i == bytes.len() {
+            break;
+        }
+        let neg = if bytes[i] == b'-' {
+            i += 1;
+            true
+        } else {
+            false
+        };
+        let mut n = 0i64;
+        while i < bytes.len() && bytes[i].is_ascii_digit() {
+            n *= 10;
+            n += (bytes[i] - b'0') as i64;
+            i += 1;
+        }
+        if neg {
+            n = -n;
+        }
+        result.push(n);
+    }
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_uints() {
+        assert_eq!(uints(""), vec![]);
+        assert_eq!(uints("1 2 3 4 5"), vec![1, 2, 3, 4, 5]);
+        assert_eq!(
+            uints("one 1 two 2 three 3 four 4 5 6 end"),
+            vec![1, 2, 3, 4, 5, 6]
+        );
+        assert_eq!(uints("Range: 10-42"), vec![10, 42]);
+        assert_eq!(
+            uints("Ranges: 10-42, 15-16, 0-8, 99-110"),
+            vec![10, 42, 15, 16, 0, 8, 99, 110]
+        );
+        assert_eq!(
+            uints("Ranges: 10-42, 15-16, 0-8, 99-110 (inclusive)"),
+            vec![10, 42, 15, 16, 0, 8, 99, 110]
+        );
+        assert_eq!(uints("Button A: X+95, Y+110"), vec![95, 110]);
+        assert_eq!(uints("----10---"), vec![10]);
+    }
+
+    #[test]
+    fn test_iints() {
+        assert_eq!(iints(""), vec![]);
+        assert_eq!(iints("-1"), vec![-1]);
+        assert_eq!(iints("1 -2 3 -4 5"), vec![1, -2, 3, -4, 5]);
+        assert_eq!(
+            iints("one -1 two 2 three -3 four 4 -5 -6 end"),
+            vec![-1, 2, -3, 4, -5, -6]
+        );
+        assert_eq!(iints("Two numbers: +10-42"), vec![10, -42]);
+        assert_eq!(
+            iints("Numbers: +10-42, +15-16, +0-8, -99+110"),
+            vec![10, -42, 15, -16, 0, -8, -99, 110]
+        );
+        assert_eq!(
+            iints("Numbers: +10-42, +15-16, +0-8, -99+110 (inclusive)"),
+            vec![10, -42, 15, -16, 0, -8, -99, 110]
+        );
+        assert_eq!(iints("Button A: X+95, Y+110"), vec![95, 110]);
+        assert_eq!(iints("Trailing minus: X-95, Y+110-"), vec![-95, 110]);
+        assert_eq!(iints("Trailing minuses: X-95, Y+110--"), vec![-95, 110]);
+        assert_eq!(iints("----10---"), vec![-10]);
+        assert_eq!(iints("a 1 b -0 negative zero"), vec![1, 0]);
+    }
+}
