Simplify logic by converting each rule into a range

Author: maneatingape

README.md

@@ -99,7 +99,7 @@ pie
 | 16 | [The Floor Will Be Lava](https://adventofcode.com/2023/day/16) | [Source](src/year2023/day16.rs) | 831 |
 | 17 | [Clumsy Crucible](https://adventofcode.com/2023/day/17) | [Source](src/year2023/day17.rs) | 2566 |
 | 18 | [Lavaduct Lagoon](https://adventofcode.com/2023/day/18) | [Source](src/year2023/day18.rs) | 19 |
-| 19 | [Aplenty](https://adventofcode.com/2023/day/19) | [Source](src/year2023/day19.rs) | 107 |
+| 19 | [Aplenty](https://adventofcode.com/2023/day/19) | [Source](src/year2023/day19.rs) | 100 |
 
 ## 2022
 

src/year2023/day19.rs

@@ -1,21 +1,38 @@
+//! # Aplenty
+//!
+//! Each rule is converted into a half open interval, including the start but excluding the end.
+//! For example:
+//!
+//! * `x > 10` => `10..4001`
+//! * `m < 20` => `1..20`
+//! * `A` => `1..4001`
+//!
+//! For part one if a category is contained in a range, we send the part to the next rule,
+//! stopping when `A` or `R` is reached.
+//!
+//! For part two we perform range splitting similar to [`Day 5`] that converts the category into
+//! 1, 2 or 3 new ranges, then sends those ranges to the respective rule.
+//!
+//! [`Day 5`]: crate::year2023::day05
 use crate::util::hash::*;
 use crate::util::iter::*;
 use crate::util::parse::*;
-use Rule::*;
-
-#[derive(Clone, Copy, Debug)]
-enum Rule<'a> {
-    Send(&'a str),
-    Less(usize, u32, &'a str),
-    Greater(usize, u32, &'a str),
-    Equal(usize, u32, &'a str),
+
+pub struct Rule<'a> {
+    start: u32,
+    end: u32,
+    category: usize,
+    next: &'a str,
 }
 
 pub struct Input<'a> {
     workflows: FastMap<&'a str, Vec<Rule<'a>>>,
     parts: &'a str,
 }
 
+/// Parse each rule from the first half of the input.
+/// Leaves the second half of the input as a `&str` as it's faster to iterate over each chunk of
+/// four numbers than to first collect into a `vec`.
 pub fn parse(input: &str) -> Input<'_> {
     let (prefix, suffix) = input.split_once("\n\n").unwrap();
     let mut workflows = FastMap::with_capacity(1000);
@@ -27,8 +44,11 @@ pub fn parse(input: &str) -> Input<'_> {
 
         for [first, second] in iter.chunk::<2>() {
             let rule = if second.is_empty() {
-                Send(first)
+                // The last rule will match everything so pick category 0 arbitrarily.
+                Rule { start: 1, end: 4001, category: 0, next: first }
             } else {
+                // Map each category to an index for convenience so that we can store a part
+                // in a fixed size array.
                 let category = match first.as_bytes()[0] {
                     b'x' => 0,
                     b'm' => 1,
@@ -38,11 +58,12 @@ pub fn parse(input: &str) -> Input<'_> {
                 };
 
                 let value: u32 = (&first[2..]).unsigned();
+                let next = second;
 
+                // Convert each rule into a half open range.
                 match first.as_bytes()[1] {
-                    b'<' => Less(category, value, second),
-                    b'>' => Greater(category, value, second),
-                    b'=' => Equal(category, value, second),
+                    b'<' => Rule { start: 1, end: value, category, next },
+                    b'>' => Rule { start: value + 1, end: 4001, category, next },
                     _ => unreachable!(),
                 }
             };
@@ -60,42 +81,23 @@ pub fn part1(input: &Input<'_>) -> u32 {
     let Input { workflows, parts } = input;
     let mut result = 0;
 
+    // We only care about the numbers and can ignore all delimeters and whitespace.
     for part in parts.iter_unsigned::<u32>().chunk::<4>() {
         let mut key = "in";
 
-        loop {
-            if key == "A" {
-                result += part.iter().sum::<u32>();
-                break;
-            }
-            if key == "R" {
-                break;
-            }
-
-            for &rule in &workflows[key] {
-                match rule {
-                    Send(next) => key = next,
-                    Less(category, value, next) => {
-                        if part[category] < value {
-                            key = next;
-                            break;
-                        }
-                    }
-                    Greater(category, value, next) => {
-                        if part[category] > value {
-                            key = next;
-                            break;
-                        }
-                    }
-                    Equal(category, value, next) => {
-                        if part[category] == value {
-                            key = next;
-                            break;
-                        }
-                    }
+        while key.len() > 1 {
+            // Find the first matching rule.
+            for &Rule { start, end, category, next } in &workflows[key] {
+                if start <= part[category] && part[category] < end {
+                    key = next;
+                    break;
                 }
             }
         }
+
+        if key == "A" {
+            result += part.iter().sum::<u32>();
+        }
     }
 
     result
@@ -104,64 +106,41 @@ pub fn part1(input: &Input<'_>) -> u32 {
 pub fn part2(input: &Input<'_>) -> u64 {
     let Input { workflows, .. } = input;
     let mut result = 0;
-    let mut todo = vec![("in", 0, [(1, 4000); 4])];
+    let mut todo = vec![("in", 0, [(1, 4001); 4])];
 
     while let Some((key, index, mut part)) = todo.pop() {
-        if key == "A" {
-            result += part.iter().map(|(s, e)| (e - s + 1) as u64).product::<u64>();
-            continue;
-        }
-        if key == "R" {
+        if key.len() == 1 {
+            if key == "A" {
+                result += part.iter().map(|(s, e)| (e - s) as u64).product::<u64>();
+            }
             continue;
         }
 
-        match workflows[key][index] {
-            Send(next) => todo.push((next, 0, part)),
-            Less(category, value, next) => {
-                let (start, end) = part[category];
-
-                if start >= value {
-                    todo.push((key, index + 1, part));
-                } else if end < value {
-                    todo.push((next, 0, part));
-                } else {
-                    part[category] = (start, value - 1);
-                    todo.push((next, 0, part));
-
-                    part[category] = (value, end);
-                    todo.push((key, index + 1, part));
-                }
+        let Rule { start: s2, end: e2, category, next } = workflows[key][index];
+        let (s1, e1) = part[category];
+
+        // x1 and x2 are the possible overlap.
+        let x1 = s1.max(s2);
+        let x2 = e1.min(e2);
+
+        if x1 >= x2 {
+            // No overlap. Check the next rating.
+            todo.push((key, index + 1, part));
+        } else {
+            // Range that overlaps with the rating.
+            part[category] = (x1, x2);
+            todo.push((next, 0, part));
+
+            // Range before rating.
+            if s1 < x1 {
+                part[category] = (s1, x1);
+                todo.push((key, index + 1, part));
             }
-            Greater(category, value, next) => {
-                let (start, end) = part[category];
-
-                if end <= value {
-                    todo.push((key, index + 1, part));
-                } else if start > value {
-                    todo.push((next, 0, part));
-                } else {
-                    part[category] = (start, value);
-                    todo.push((key, index + 1, part));
-
-                    part[category] = (value + 1, end);
-                    todo.push((next, 0, part));
-                }
-            }
-            Equal(category, value, next) => {
-                let (start, end) = part[category];
-
-                if start > value || end < value {
-                    todo.push((key, index + 1, part));
-                } else {
-                    part[category] = (start, value - 1);
-                    todo.push((key, index + 1, part));
 
-                    part[category] = (value, value);
-                    todo.push((next, 0, part));
-
-                    part[category] = (value + 1, end);
-                    todo.push((key, index + 1, part));
-                }
+            // Range after rating.
+            if x2 < e1 {
+                part[category] = (x2, e1);
+                todo.push((key, index + 1, part));
             }
         }
     }