Day 7

advent_of_code_2024/src/day6/part2.rs

@@ -50,7 +50,7 @@ fn detect_loop(grid: &[Vec<u8>], start_pos: (i64, i64), start_dir: usize) -> (bo
     }
 }
 
-pub fn draw_walked_grid(grid: &[Vec<u8>], steps: &HashSet<(i64, i64, usize)>) {
+pub fn _draw_walked_grid(grid: &[Vec<u8>], steps: &HashSet<(i64, i64, usize)>) {
     let steps = steps.iter().map(|tup| ((tup.0, tup.1), tup.2)).collect::<HashMap<_, _>>();
     
     for (ypos, line) in grid.iter().enumerate() {
@@ -92,7 +92,7 @@ pub fn solve(input: &str) {
         if new_position != start {
             let mut test_grid = grid.clone();
             test_grid[new_position.1 as usize][new_position.0 as usize] = b'@';
-            let (looped, steps) = detect_loop(&test_grid, start, start_dir);
+            let (looped, _) = detect_loop(&test_grid, start, start_dir);
             if looped {
                 looping_blockades.insert(new_position);
             }

advent_of_code_2024/src/day7/part1.rs

@@ -1,4 +1,38 @@
+#[derive(Debug)]
+struct Equation {
+    result: u64,
+    values: Vec<u64>,
+}
+
+fn recurse_equation(equation: &Equation, value: u64, index: usize) -> bool {
+    if index == equation.values.len() {
+        return value == equation.result;
+    }
+    
+    if recurse_equation(equation, value + equation.values[index], index + 1) ||
+       recurse_equation(equation, value * equation.values[index], index + 1)
+    {
+        return true;
+    }
+    false
+}
 
 pub fn solve(input: &str) {
-    
+    let equations =
+        input.lines()
+             .map(|line| {
+                 let (result, values) = line.split_once(": ").unwrap();
+                 Equation { result: result.parse().unwrap(),
+                            values: values.split_whitespace().map(|value| value.parse::<u64>().unwrap()).collect(), }
+             })
+             .collect::<Vec<_>>();
+
+    let mut sum_of_equations = 0;
+    for equation in equations.iter() {
+        if recurse_equation(equation, 0, 0) {
+            sum_of_equations += equation.result;
+        }
+    }
+
+    println!("Sum of equations: {}", sum_of_equations);
 }

advent_of_code_2024/src/day7/part2.rs

@@ -1,4 +1,39 @@
+#[derive(Debug)]
+struct Equation {
+    result: u64,
+    values: Vec<u64>,
+}
+
+fn merge_numbers(lhs: u64, rhs: u64) -> u64 {
+    format!("{}{}", lhs, rhs).parse().unwrap()
+}
+
+fn recurse_equation(equation: &Equation, value: u64, index: usize) -> bool {
+    if index == equation.values.len() {
+        return value == equation.result;
+    }
+
+    recurse_equation(equation, value + equation.values[index], index + 1) ||
+    recurse_equation(equation, value * equation.values[index], index + 1) ||
+    recurse_equation(equation, merge_numbers(value, equation.values[index]), index + 1)
+}
 
 pub fn solve(input: &str) {
-    
-}
+    let equations =
+        input.lines()
+             .map(|line| {
+                 let (result, values) = line.split_once(": ").unwrap();
+                 Equation { result: result.parse().unwrap(),
+                            values: values.split_whitespace().map(|value| value.parse::<u64>().unwrap()).collect(), }
+             })
+             .collect::<Vec<_>>();
+
+    let mut sum_of_equations = 0;
+    for equation in equations.iter() {
+        if recurse_equation(equation, 0, 0) {
+            sum_of_equations += equation.result;
+        }
+    }
+
+    println!("Sum of equations: {}", sum_of_equations);
+}

advent_of_code_2024/src/day7/test.txt

@@ -0,0 +1,9 @@
+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

advent_of_code_2024/src/main.rs

@@ -18,4 +18,5 @@ pub fn main() {
     solve_day!(4);
     solve_day!(5);
     solve_day!(6);
+    solve_day!(7);
 }