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) | 12300 |
 
 ## 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,81 @@
+//! # 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 basic(&equation, equation[0], equation[1], 2) {
+            part_one += equation[0];
+            part_two += equation[0];
+        } else if advanced(&equation, equation[0], equation[1], 2) {
+            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 basic(terms: &[u64], test_value: u64, total: u64, index: usize) -> bool {
+    if index == terms.len() {
+        return total == test_value;
+    }
+    if total > test_value {
+        return false;
+    }
+
+    basic(terms, test_value, total + terms[index], index + 1)
+        || basic(terms, test_value, total * terms[index], index + 1)
+}
+
+fn advanced(terms: &[u64], test_value: u64, total: u64, index: usize) -> bool {
+    if index == terms.len() {
+        return total == test_value;
+    }
+    if total > test_value {
+        return false;
+    }
+
+    advanced(terms, test_value, total + terms[index], index + 1)
+        || advanced(terms, test_value, total * terms[index], index + 1)
+        || advanced(terms, test_value, total * next_power(terms[index]) + terms[index], index + 1)
+}
+
+#[inline]
+fn next_power(n: u64) -> u64 {
+    if n < 10 {
+        10
+    } else if n < 100 {
+        100
+    } else if n < 1000 {
+        1000
+    } else {
+        unreachable!()
+    }
+}

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);
+}