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,64 @@
+//! # Bridge Repair
+//!
+//! Concenation in part two can be implemented without time consuming conversion to or from strings.
+//! Instead multiply the left term by the next power of ten greater than the right term, then add
+//! the right term. For example:
+//!
+//! * 15 || 6 = 15 * 10 + 6
+//! * 17 || 14 = 17 * 100 + 14
+//!
+//! Finding the next power of 10 is quick as the input only contains 1 to 3 digit numbers.
+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 check(&equation, equation[0], equation.len() - 1, false) {
+            part_one += equation[0];
+            part_two += equation[0];
+        } else if check(&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 check(terms: &[u64], test_value: u64, index: usize, concat: bool) -> bool {
+    (test_value == 0)
+        || (concat
+            && test_value % next_power_of_ten(terms[index]) == terms[index]
+            && check(terms, test_value / next_power_of_ten(terms[index]), index - 1, concat))
+        || (test_value % terms[index] == 0
+            && check(terms, test_value / terms[index], index - 1, concat))
+        || (test_value >= terms[index]
+            && check(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);
+}