Year 2024 Day 7

Author: maneatingape

README.md

@@ -78,6 +78,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 4 | [Ceres Search](https://adventofcode.com/2024/day/4) | [Source](src/year2024/day04.rs) | 77 |
 | 5 | [Print Queue](https://adventofcode.com/2024/day/5) | [Source](src/year2024/day05.rs) | 18 |
 | 6 | [Guard Gallivant](https://adventofcode.com/2024/day/6) | [Source](src/year2024/day06.rs) | 386 |
+| 7 | [Bridge Repair](https://adventofcode.com/2024/day/7) | [Source](src/year2024/day07.rs) | 220 |
 
 ## 2023
 

benches/benchmark.rs

@@ -298,4 +298,5 @@ mod year2024 {
     benchmark!(year2024, day04);
     benchmark!(year2024, day05);
     benchmark!(year2024, day06);
+    benchmark!(year2024, day07);
 }

src/lib.rs

@@ -297,4 +297,5 @@ pub mod year2024 {
     pub mod day04;
     pub mod day05;
     pub mod day06;
+    pub mod day07;
 }

src/main.rs

@@ -367,5 +367,6 @@ fn year2024() -> Vec<Solution> {
         solution!(year2024, day04),
         solution!(year2024, day05),
         solution!(year2024, day06),
+        solution!(year2024, day07),
     ]
 }

src/year2024/day07.rs

@@ -0,0 +1,102 @@
+//! # Bridge Repair
+//!
+//! The equations can be validated using a recursive solution that checks all possible combinations
+//! of operators. However the number of states to check grows exponentially as 2ⁿ in part one
+//! and 3ⁿ in part two.
+//!
+//! As much faster approach works in reverse from the end of the equation to prune as many states
+//! as possible by checking which operations are possible. For example:
+//!
+//! ```none
+//!     Test Value: 123456
+//!     Equation: 2 617 56
+//!     Addition is possible as 123456 >= 56
+//!     Multiplication is not possible as 56 is not a factor of 123456
+//!     Concatenation is possible as 1234 || 56 = 123456
+//! ```
+//!
+//! Following the concatenation branch and applying an inverse concentation
+//! (the full solution would also follow the addition branch):
+//!
+//! ```none
+//!     Test Value: 1234
+//!     Equation: 2 617
+//!     Addition is possible as 1234 >= 617
+//!     Multiplication is possible as 2 * 617 = 1234
+//!     Concatenation is not possible as 1234 does not end in 617
+//! ```
+//!
+//! Following the multiplication branch:
+//!
+//! ```none
+//!     Test Value: 2
+//!     Equation: 2
+//!     Addition is possible
+//!     Multiplication is possible
+//!     Concatenation is possible
+//! ```
+//!
+//! Following any of theses branches results in a test value of 0 which means that all terms
+//! have been applied successfully and the equation is valid.
+//!
+//! Inverse concenation can be implemented without time consuming conversion to or from
+//! strings by dividing the left term by the next power of ten greater than the right term.
+//! For example:
+//!
+//! * 7 || 9 => 79 => 79 / 10 => 7
+//! * 12 || 34 => 1234 => 1234 / 100 => 12
+//! * 123 || 789 => 123789 => 123789 / 1000 => 123
+use crate::util::parse::*;
+
+type Input = (u64, u64);
+
+pub fn parse(input: &str) -> Input {
+    let mut equation = Vec::new();
+    let mut part_one = 0;
+    let mut part_two = 0;
+
+    for line in input.lines() {
+        equation.extend(line.iter_unsigned::<u64>());
+
+        // If an equation is valid for part one then it's also valid for part two.
+        if valid(&equation, equation[0], equation.len() - 1, false) {
+            part_one += equation[0];
+            part_two += equation[0];
+        } else if valid(&equation, equation[0], equation.len() - 1, true) {
+            part_two += equation[0];
+        }
+
+        equation.clear();
+    }
+
+    (part_one, part_two)
+}
+
+pub fn part1(input: &Input) -> u64 {
+    input.0
+}
+
+pub fn part2(input: &Input) -> u64 {
+    input.1
+}
+
+fn valid(terms: &[u64], test_value: u64, index: usize, concat: bool) -> bool {
+    (test_value == 0)
+        || (concat
+            && test_value % next_power_of_ten(terms[index]) == terms[index]
+            && valid(terms, test_value / next_power_of_ten(terms[index]), index - 1, concat))
+        || (test_value % terms[index] == 0
+            && valid(terms, test_value / terms[index], index - 1, concat))
+        || (test_value >= terms[index]
+            && valid(terms, test_value - terms[index], index - 1, concat))
+}
+
+fn next_power_of_ten(n: u64) -> u64 {
+    let mut power = 10;
+
+    while power <= n {
+        power *= 10;
+    }
+
+    power
+}

tests/test.rs

@@ -287,4 +287,5 @@ mod year2024 {
     mod day04_test;
     mod day05_test;
     mod day06_test;
+    mod day07_test;
 }

tests/year2024/day07_test.rs

@@ -0,0 +1,24 @@
+use aoc::year2024::day07::*;
+
+const EXAMPLE: &str = "\
+190: 10 19
+3267: 81 40 27
+83: 17 5
+156: 15 6
+7290: 6 8 6 15
+161011: 16 10 13
+192: 17 8 14
+21037: 9 7 18 13
+292: 11 6 16 20";
+
+#[test]
+fn part1_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part1(&input), 3749);
+}
+
+#[test]
+fn part2_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part2(&input), 11387);
+}