2017 day 19

ictrobot · ictrobot · commit 8e51d9d2823d · 2024-11-03T22:34:58.000Z
diff --git a/crates/utils/src/number.rs b/crates/utils/src/number.rs
@@ -1,6 +1,4 @@
 //! Traits for using numbers as generic data types.
-//!
-//! Machine-dependent integer types aren't unsupported.
 
 use std::fmt::Debug;
 use std::iter::{Product, Sum};
@@ -80,13 +78,23 @@ pub trait Integer:
 }
 
 /// Trait implemented by the primitive unsigned integer types.
-pub trait UnsignedInteger: Integer + From<u8> {}
+pub trait UnsignedInteger: Integer + From<u8> {
+    type Signed: SignedInteger;
+
+    #[must_use]
+    fn wrapping_add_signed(self, rhs: Self::Signed) -> Self;
+}
 
 /// Trait implemented by the primitive signed integer types.
-pub trait SignedInteger: Integer + Signed {}
+pub trait SignedInteger: Integer + Signed {
+    type Unsigned: UnsignedInteger;
+
+    #[must_use]
+    fn unsigned_abs(self) -> Self::Unsigned;
+}
 
 macro_rules! number_impl {
-    (uint => $($t:ty),+) => {
+    (uint => $($t:ty: $signed:ty),+) => {
         $(impl Number for $t {
             const ZERO: Self = 0;
             const ONE: Self = 1;
@@ -106,9 +114,16 @@ macro_rules! number_impl {
 
         number_impl! {@common integer => $($t),+}
 
-        $(impl UnsignedInteger for $t {})+
+        $(impl UnsignedInteger for $t {
+            type Signed = $signed;
+
+            #[inline]
+            fn wrapping_add_signed(self, rhs: Self::Signed) -> Self {
+                self.wrapping_add_signed(rhs)
+            }
+        })+
     };
-    (int => $($t:ty),+) => {
+    (int => $($t:ty: $unsigned:ty ),+) => {
         $(impl Number for $t {
             const ZERO: Self = 0;
             const ONE: Self = 1;
@@ -129,7 +144,14 @@ macro_rules! number_impl {
         number_impl! {@common integer => $($t),+}
         number_impl! {@common signed => $($t),+}
 
-        $(impl SignedInteger for $t {})+
+        $(impl SignedInteger for $t {
+            type Unsigned = $unsigned;
+
+            #[inline]
+            fn unsigned_abs(self) -> Self::Unsigned {
+                self.unsigned_abs()
+            }
+        })+
     };
     (float => $($t:ty),+) => {
         $(impl Number for $t {
@@ -181,8 +203,8 @@ macro_rules! number_impl {
         })+
     };
 }
-number_impl! {uint => u8, u16, u32, u64, u128}
-number_impl! {int => i8, i16, i32, i64, i128}
+number_impl! {uint => u8: i8, u16: i16, u32: i32, u64: i64, u128: i128, usize: isize}
+number_impl! {int => i8: u8, i16: u16, i32: u32, i64: u64, i128: u128, isize: usize}
 number_impl! {float => f32, f64}
 
 /// Checks if the provided unsigned integer `n` is a prime number.
diff --git a/crates/utils/src/point.rs b/crates/utils/src/point.rs
@@ -1,13 +1,13 @@
 //! 2D point implementation.
 
-use crate::number::{Number, Signed};
+use crate::number::{Number, Signed, SignedInteger, UnsignedInteger};
 use std::fmt::Debug;
 use std::ops::{Add, AddAssign, Mul, MulAssign, Sub, SubAssign};
 
 macro_rules! point_impl {
-    ($v:vis struct $s:ident{$($f:ident),+}) => {
+    ($(#[$m:meta])* $v:vis struct $s:ident{$($f:ident),+}) => {
         #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Default)]
-        $v struct $s<T: Number> {
+        $(#[$m])* $v struct $s<T: Number> {
             $(pub $f: T,)+
         }
 
@@ -26,6 +26,30 @@ macro_rules! point_impl {
             pub fn manhattan_distance(self) -> T {
                 T::ZERO $(+ self.$f.abs())+
             }
+
+            /// Returns the manhattan distance from the origin.
+            #[inline]
+            #[must_use]
+            pub fn manhattan_distance_unsigned(self) -> T::Unsigned
+            where
+                T: SignedInteger
+            {
+                T::Unsigned::ZERO $(+ self.$f.unsigned_abs())+
+            }
+
+            /// Add the provided signed point, wrapping on overflow.
+            ///
+            /// Useful for adding a signed direction onto an unsigned position.
+            #[inline]
+            #[must_use]
+            pub fn wrapping_add_signed(self, rhs: $s<T::Signed>) -> Self
+            where
+                T: UnsignedInteger,
+            {
+                Self{
+                    $($f: self.$f.wrapping_add_signed(rhs.$f),)+
+                }
+            }
         }
 
         impl<T: Number> Add for $s<T> {
@@ -87,7 +111,10 @@ macro_rules! point_impl {
     };
 }
 
-point_impl! {pub struct Point2D{x, y}}
+point_impl! {
+    /// Struct representing a 2D point or vector.
+    pub struct Point2D{x, y}
+}
 
 impl<T: Signed> Point2D<T> {
     pub const UP: Self = Self {
diff --git a/crates/year2016/src/day01.rs b/crates/year2016/src/day01.rs
@@ -25,7 +25,7 @@ impl Day01 {
     }
 
     #[must_use]
-    pub fn part1(&self) -> i32 {
+    pub fn part1(&self) -> u32 {
         let mut pos = Point2D::ORIGIN;
         let mut dir = Point2D::UP;
 
@@ -37,11 +37,11 @@ impl Day01 {
             pos += dir * i32::from(steps);
         }
 
-        pos.manhattan_distance()
+        pos.manhattan_distance_unsigned()
     }
 
     #[must_use]
-    pub fn part2(&self) -> i32 {
+    pub fn part2(&self) -> u32 {
         let mut pos: Point2D<i32> = Point2D::ORIGIN;
         let mut dir = Point2D::UP;
         let mut visited = HashSet::new();
@@ -54,7 +54,7 @@ impl Day01 {
             for _ in 0..steps {
                 pos += dir;
                 if !visited.insert(pos) {
-                    return pos.manhattan_distance();
+                    return pos.manhattan_distance_unsigned();
                 }
             }
         }
@@ -63,7 +63,7 @@ impl Day01 {
     }
 }
 
-examples!(Day01 -> (i32, i32) [
+examples!(Day01 -> (u32, u32) [
     {input: "R2, L3", part1: 5},
     {input: "R2, R2, R2", part1: 2},
     {input: "R5, L5, R5, R3", part1: 12},
diff --git a/crates/year2017/examples/day19_example0.txt b/crates/year2017/examples/day19_example0.txt
@@ -0,0 +1,6 @@
+     |
+     |  +--+
+     A  |  C
+ F---|--|-E---+
+     |  |  |  D
+     +B-+  +--+
diff --git a/crates/year2017/src/day19.rs b/crates/year2017/src/day19.rs
@@ -0,0 +1,90 @@
+use utils::point::Point2D;
+use utils::prelude::*;
+
+/// Following a path.
+#[derive(Clone, Debug)]
+pub struct Day19 {
+    part1: String,
+    part2: u32,
+}
+
+impl Day19 {
+    pub fn new(input: &str, _: InputType) -> Result<Self, InputError> {
+        let lines = input.lines().collect::<Vec<_>>();
+        let lookup = |p: Point2D<usize>| {
+            if p.y < lines.len() && p.x < lines[p.y].len() {
+                Some(lines[p.y].as_bytes()[p.x])
+            } else {
+                None
+            }
+        };
+
+        let Some(start_col) = lines.first().and_then(|l| l.find('|')) else {
+            return Err(InputError::new(input, 0, "expected '|' on the first line"));
+        };
+        let mut pos = Point2D::new(start_col, 0);
+        let mut dir = Point2D::new(0, 1);
+
+        let mut letters = String::new();
+        let mut steps = 1;
+        loop {
+            match lookup(pos)
+                .ok_or_else(|| InputError::new(input, 0, "path leads outside the input"))?
+            {
+                b'|' | b'-' => {}
+                b'+' => {
+                    let left = lookup(pos.wrapping_add_signed(dir.turn_left())).unwrap_or(b' ');
+                    let right = lookup(pos.wrapping_add_signed(dir.turn_right())).unwrap_or(b' ');
+                    if matches!(left, b'|' | b'-' | b'A'..=b'Z') && right == b' ' {
+                        dir = dir.turn_left();
+                    } else if matches!(right, b'|' | b'-' | b'A'..=b'Z') && left == b' ' {
+                        dir = dir.turn_right();
+                    } else {
+                        return Err(InputError::new(
+                            input,
+                            &lines[pos.y][pos.x..],
+                            "invalid turn",
+                        ));
+                    }
+                }
+                letter @ b'A'..=b'Z' => {
+                    letters.push(letter as char);
+
+                    // The path is allowed to end after letters
+                    if lookup(pos.wrapping_add_signed(dir)).unwrap_or(b' ') == b' ' {
+                        break;
+                    }
+                }
+                _ => {
+                    return Err(InputError::new(
+                        input,
+                        &lines[pos.y][pos.x..],
+                        "expected '|', '-', '+' or 'A'-'Z'",
+                    ));
+                }
+            }
+
+            pos = pos.wrapping_add_signed(dir);
+            steps += 1;
+        }
+
+        Ok(Self {
+            part1: letters,
+            part2: steps,
+        })
+    }
+
+    #[must_use]
+    pub fn part1(&self) -> &str {
+        &self.part1
+    }
+
+    #[must_use]
+    pub fn part2(&self) -> u32 {
+        self.part2
+    }
+}
+
+examples!(Day19 -> (&'static str, u32) [
+    {file: "day19_example0.txt", part1: "ABCDEF", part2: 38},
+]);
diff --git a/crates/year2017/src/lib.rs b/crates/year2017/src/lib.rs
@@ -22,4 +22,5 @@ utils::year!(2017 => year2017, ${
     16 => day16::Day16,
     17 => day17::Day17,
     18 => day18::Day18,
+    19 => day19::Day19,
 });

Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ impl Day01 {`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`#[must_use]`
`28`		`- pub fn part1(&self) -> i32 {`
	`28`	`+ pub fn part1(&self) -> u32 {`
`29`	`29`	`let mut pos = Point2D::ORIGIN;`
`30`	`30`	`let mut dir = Point2D::UP;`
`31`	`31`
`@@ -37,11 +37,11 @@ impl Day01 {`
`37`	`37`	`pos += dir * i32::from(steps);`
`38`	`38`	`}`
`39`	`39`
`40`		`- pos.manhattan_distance()`
	`40`	`+ pos.manhattan_distance_unsigned()`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`#[must_use]`
`44`		`- pub fn part2(&self) -> i32 {`
	`44`	`+ pub fn part2(&self) -> u32 {`
`45`	`45`	`let mut pos: Point2D<i32> = Point2D::ORIGIN;`
`46`	`46`	`let mut dir = Point2D::UP;`
`47`	`47`	`let mut visited = HashSet::new();`
`@@ -54,7 +54,7 @@ impl Day01 {`
`54`	`54`	`for _ in 0..steps {`
`55`	`55`	`pos += dir;`
`56`	`56`	`if !visited.insert(pos) {`
`57`		`- return pos.manhattan_distance();`
	`57`	`+ return pos.manhattan_distance_unsigned();`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`	`}`
`@@ -63,7 +63,7 @@ impl Day01 {`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`
`66`		`-examples!(Day01 -> (i32, i32) [`
	`66`	`+examples!(Day01 -> (u32, u32) [`
`67`	`67`	`{input: "R2, L3", part1: 5},`
`68`	`68`	`{input: "R2, R2, R2", part1: 2},`
`69`	`69`	`{input: "R5, L5, R5, R3", part1: 12},`
-Original file line number
+Diff line change
@@ @@ -0,0 +1,6 @@ @@
 +     |
 +     |  +--+
 +     A  |  C
 + F---|--|-E---+
 +     |  |  |  D
 +     +B-+  +--+