added day 6 (incomplete)

src/bin/2024/06.rs

@@ -0,0 +1,173 @@
+#[allow(unused_imports)]
+use advent_of_code::{
+    include_data, include_example,
+    strings::{convert_to_array, line_to_char},
+    KartesianDirection,
+};
+use advent_of_code::{Kartesian, Table};
+use log::debug;
+use num::Integer;
+
+include_data!(DATA 2024 06);
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+struct DirectionalKartesian<T: Integer> {
+    x: T,
+    y: T,
+    dir: KartesianDirection,
+}
+impl<T: Integer> From<(Kartesian<T>, KartesianDirection)> for DirectionalKartesian<T> {
+    fn from(value: (Kartesian<T>, KartesianDirection)) -> Self {
+        DirectionalKartesian {
+            x: value.0.x,
+            y: value.0.y,
+            dir: value.1,
+        }
+    }
+}
+
+impl<T: Integer + Copy> Into<(Kartesian<T>, KartesianDirection)> for &DirectionalKartesian<T> {
+    fn into(self) -> (Kartesian<T>, KartesianDirection) {
+        (
+            Kartesian {
+                x: self.x,
+                y: self.y,
+            },
+            self.dir,
+        )
+    }
+}
+
+impl<T: Integer> DirectionalKartesian<T> {
+    fn kartesian(self) -> Kartesian<T> {
+        Kartesian::new(self.x, self.y)
+    }
+}
+
+fn find_guard(map: Table) -> Kartesian<i32> {
+    let mut position = Kartesian::default();
+    for line in map {
+        for char in line {
+            if char == '^' {
+                return position;
+            }
+            position.y += 1;
+        }
+        position.y = 0;
+        position.x += 1;
+    }
+    unreachable!()
+}
+
+fn get_path(map: Table) -> Vec<DirectionalKartesian<i32>> {
+    let mut position = (find_guard(map.clone()), KartesianDirection::Top);
+    let maximum = Kartesian::new(map.len() as i32, map[0].len() as i32);
+    debug!(
+        "Guard is on coordinate {}:{}",
+        position.0.x + 1,
+        position.0.y + 1
+    );
+    let mut passed = Vec::new();
+    passed.push(position.into());
+    loop {
+        position.0 = match position.0.checked_add_max(position.1.vector(), maximum) {
+            None => {
+                debug!("Guard left the space after {} steps", passed.len());
+                return passed;
+            }
+            Some(pos) => pos,
+        };
+        if map[position.0.x as usize][position.0.y as usize] != '#' {
+            passed.push(position.into());
+            continue;
+        }
+        position.0 -= position.1.vector();
+        debug!(
+            "Guard turned right on {}:{}",
+            position.0.x + 1,
+            position.0.y + 1
+        );
+        position.1 = position.1.clockwise(false);
+    }
+}
+
+fn solver1(input: &str) -> usize {
+    let map = convert_to_array(input, line_to_char);
+    let mut path = get_path(map);
+    path.sort();
+    path.dedup_by_key(|p| (p.x, p.y));
+    path.len()
+}
+
+fn is_looping(
+    path: Vec<DirectionalKartesian<i32>>,
+    start_point: DirectionalKartesian<i32>,
+) -> bool {
+    false
+}
+
+#[allow(unused_variables, unused_mut)]
+fn solver2(input: &str) -> usize {
+    let map = convert_to_array(input, line_to_char);
+    let maximum = Kartesian::new(map.len() as i32, map[0].len() as i32);
+    let mut path = get_path(map.clone());
+    let mut p = path.iter();
+    let mut looppoints = Vec::new();
+    let startpoint = p.next().unwrap().kartesian();
+
+    let mut currentpoint: (Kartesian<i32>, KartesianDirection);
+    for point in p {
+        if point.kartesian() == startpoint {
+            continue;
+        }
+        currentpoint = point.into();
+        currentpoint.1 = currentpoint.1.clockwise(false);
+        loop {
+            currentpoint.0 = match currentpoint
+                .0
+                .checked_add_max(currentpoint.1.vector(), maximum)
+            {
+                None => break,
+                Some(p) => p,
+            };
+            if path.contains(&currentpoint.into()) {
+                looppoints.push(point.kartesian());
+                break;
+            }
+            if map[currentpoint.0.x as usize][currentpoint.0.y as usize] == '#' {
+                currentpoint.0 -= currentpoint.1.vector();
+                currentpoint.1 = currentpoint.1.clockwise(false)
+            }
+        }
+    }
+    looppoints.dedup();
+    looppoints.len()
+}
+
+fn main() {
+    println!(
+        "Guard left the space after walking through {} distinct positions",
+        solver1(DATA)
+    );
+    println!(
+        "There are {} positions that are good for loops",
+        solver2(DATA)
+    );
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    include_example!(EXAMPLE 2024 06);
+
+    #[test]
+    fn test_solution_1() {
+        assert_eq!(solver1(EXAMPLE), 41);
+    }
+
+    #[test]
+    fn test_solution_2() {
+        assert_eq!(solver2(EXAMPLE), 6);
+    }
+}

src/lib.rs

@@ -5,6 +5,8 @@ use num::*;
 pub mod strings;
 pub use advent_of_code_macros::*;
 
+pub type Table = Vec<Vec<char>>;
+
 pub fn matrix(zero: bool, diag: bool, non_diag: bool) -> Vec<(i32, i32)> {
     const MIN: i32 = -1;
     const MAX: i32 = 1;
@@ -47,7 +49,7 @@ impl<T: Integer> Add for Kartesian<T> {
     type Output = Kartesian<T>;
 }
 
-impl<T: Integer + Euclidian> AddAssign for Kartesian<T> {
+impl<T: Integer + AddAssign> AddAssign for Kartesian<T> {
     fn add_assign(&mut self, rhs: Self) {
         self.x += rhs.x;
         self.y += rhs.y;
@@ -65,7 +67,7 @@ impl<T: Integer> Sub for Kartesian<T> {
     type Output = Kartesian<T>;
 }
 
-impl<T: Integer + Euclidian> SubAssign for Kartesian<T> {
+impl<T: Integer + SubAssign> SubAssign for Kartesian<T> {
     fn sub_assign(&mut self, rhs: Self) {
         self.x -= rhs.x;
         self.y -= rhs.y;
@@ -78,6 +80,31 @@ impl<T: Integer> Kartesian<T> {
     }
 }
 
+impl<T: Integer + CheckedAdd + Default> Kartesian<T> {
+    pub fn checked_add_max(self, rhs: Kartesian<T>, max: Kartesian<T>) -> Option<Kartesian<T>> {
+        let mut new = Kartesian::default();
+        new.x = match self.x.checked_add(&rhs.x) {
+            None => return None,
+            Some(x) => {
+                if x < T::default() || x >= max.x {
+                    return None;
+                }
+                x
+            }
+        };
+        new.y = match self.y.checked_add(&rhs.y) {
+            None => return None,
+            Some(y) => {
+                if y < T::default() || y >= max.y {
+                    return None;
+                }
+                y
+            }
+        };
+        Some(new)
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Euclidian<T>
 where
@@ -100,7 +127,7 @@ impl<T: Integer> Add for Euclidian<T> {
     type Output = Euclidian<T>;
 }
 
-impl<T: Integer + Euclidian> AddAssign for Euclidian<T> {
+impl<T: Integer + AddAssign> AddAssign for Euclidian<T> {
     fn add_assign(&mut self, rhs: Self) {
         self.x += rhs.x;
         self.y += rhs.y;
@@ -120,7 +147,7 @@ impl<T: Integer> Sub for Euclidian<T> {
     type Output = Euclidian<T>;
 }
 
-impl<T: Integer + Euclidian> SubAssign for Euclidian<T> {
+impl<T: Integer + SubAssign> SubAssign for Euclidian<T> {
     fn sub_assign(&mut self, rhs: Self) {
         self.x -= rhs.x;
         self.y -= rhs.y;
@@ -129,13 +156,11 @@ impl<T: Integer + Euclidian> SubAssign for Euclidian<T> {
 }
 
 impl<T: Integer> Euclidian<T> {
-    pub const fn new(x: T, y: T) -> Self {
+    pub const fn new(x: T, y: T, z: T) -> Self {
         Self { x: x, y: y, z: z }
     }
 }
 
-pub type Table = Vec<Vec<char>>;
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub enum KartesianDirection {
     TopLeft,
@@ -167,4 +192,77 @@ impl KartesianDirection {
             },
         }
     }
+
+    pub fn clockwise(self, diagonal: bool) -> KartesianDirection {
+        match (self, diagonal) {
+            (KartesianDirection::TopLeft, _) => Self::Top,
+            (KartesianDirection::Top, true) => Self::TopRight,
+            (KartesianDirection::Top, false) => Self::Right,
+            (KartesianDirection::TopRight, _) => Self::Right,
+            (KartesianDirection::Left, true) => Self::TopLeft,
+            (KartesianDirection::Left, false) => Self::Top,
+            (KartesianDirection::None, _) => Self::None,
+            (KartesianDirection::Right, true) => Self::BottomRight,
+            (KartesianDirection::Right, false) => Self::Bottom,
+            (KartesianDirection::BottomLeft, _) => Self::Left,
+            (KartesianDirection::Bottom, true) => Self::BottomLeft,
+            (KartesianDirection::Bottom, false) => Self::Left,
+            (KartesianDirection::BottomRight, _) => Self::Bottom,
+        }
+    }
+
+    pub fn anticlockwise(self, diagonal: bool) -> KartesianDirection {
+        match (self, diagonal) {
+            (KartesianDirection::TopLeft, _) => Self::Left,
+            (KartesianDirection::Top, true) => Self::TopLeft,
+            (KartesianDirection::Top, false) => Self::Left,
+            (KartesianDirection::TopRight, _) => Self::Top,
+            (KartesianDirection::Left, true) => Self::BottomLeft,
+            (KartesianDirection::Left, false) => Self::Bottom,
+            (KartesianDirection::None, _) => Self::None,
+            (KartesianDirection::Right, true) => Self::TopRight,
+            (KartesianDirection::Right, false) => Self::Top,
+            (KartesianDirection::BottomLeft, _) => Self::Bottom,
+            (KartesianDirection::Bottom, true) => Self::BottomRight,
+            (KartesianDirection::Bottom, false) => Self::Right,
+            (KartesianDirection::BottomRight, _) => Self::Right,
+        }
+    }
+}
+
+#[test]
+fn test_clockwise() {
+    let mut current = KartesianDirection::Top;
+    let clock = [
+        KartesianDirection::Top,
+        KartesianDirection::TopRight,
+        KartesianDirection::Right,
+        KartesianDirection::BottomRight,
+        KartesianDirection::Bottom,
+        KartesianDirection::BottomLeft,
+        KartesianDirection::Left,
+        KartesianDirection::TopLeft,
+    ];
+    for hand in clock {
+        assert_eq!(current, hand);
+        current = current.clockwise(true);
+    }
+}
+#[test]
+fn test_anticlockwise() {
+    let mut current = KartesianDirection::Top;
+    let clock = [
+        KartesianDirection::Top,
+        KartesianDirection::TopLeft,
+        KartesianDirection::Left,
+        KartesianDirection::BottomLeft,
+        KartesianDirection::Bottom,
+        KartesianDirection::BottomRight,
+        KartesianDirection::Right,
+        KartesianDirection::TopRight,
+    ];
+    for hand in clock {
+        assert_eq!(current, hand);
+        current = current.anticlockwise(true);
+    }
 }