Day 8

Cargo.lock

@@ -22,6 +22,7 @@ name = "advent"
 version = "0.1.0"
 dependencies = [
  "dotenvy",
+ "itertools",
  "rayon",
  "regex",
  "reqwest",
@@ -586,6 +587,15 @@ version = "2.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ddc24109865250148c2e0f3d25d4f0f479571723792d3802153c60922a4fb708"
 
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.14"

Cargo.toml

@@ -5,6 +5,7 @@ edition = "2021"
 
 [dependencies]
 dotenvy = "0.15.7"
+itertools = "0.13.0"
 rayon = "1.10.0"
 regex = "1.11.1"
 reqwest = { version = "0.12.9", features = ["blocking"] }

src/day7.rs

@@ -0,0 +1,67 @@
+use itertools::{repeat_n, Itertools};
+use rayon::prelude::*;
+use regex::Regex;
+
+pub fn day7() {
+    let lines: Vec<(u64, Vec<u64>)> = parse_input(&crate::input(7));
+
+    let simple_operations = vec![Operation::Add, Operation::Mul];
+    let simple_operations_total: u64 = lines
+        .par_iter()
+        .filter(|(goal, operands)| possible_totals(operands, &simple_operations).contains(goal))
+        .map(|(goal, _)| goal)
+        .sum();
+
+    let all_operations = vec![Operation::Add, Operation::Mul, Operation::Cat];
+    let all_operations_total: u64 = lines
+        .par_iter()
+        .filter(|(goal, operands)| possible_totals(operands, &all_operations).contains(goal))
+        .map(|(goal, _)| goal)
+        .sum();
+
+    println!("Total for +/*: {}", simple_operations_total);
+    println!("Total for All: {}", all_operations_total);
+}
+
+fn possible_totals(operands: &Vec<u64>, operations: &Vec<Operation>) -> Vec<u64> {
+    repeat_n(operations, operands.len() - 1)
+        .multi_cartesian_product()
+        .map(|operations| {
+            operands[1..]
+                .iter()
+                .zip(operations)
+                .fold(operands[0], |acc, (e, op)| op.apply(acc, *e))
+        })
+        .collect()
+}
+
+fn parse_input(input: &str) -> Vec<(u64, Vec<u64>)> {
+    input
+        .lines()
+        .map(|line| {
+            let all: Vec<u64> = Regex::new(r"\D+")
+                .unwrap()
+                .split(line)
+                .map(|s| s.parse().unwrap())
+                .collect();
+            (all[0], all[1..].to_vec())
+        })
+        .collect()
+}
+
+#[derive(Clone)]
+enum Operation {
+    Add,
+    Mul,
+    Cat,
+}
+
+impl Operation {
+    fn apply(&self, a: u64, b: u64) -> u64 {
+        match self {
+            Self::Add => a + b,
+            Self::Mul => a * b,
+            Self::Cat => (a.to_string() + &b.to_string()).parse().unwrap(),
+        }
+    }
+}

src/day8.rs

@@ -0,0 +1,57 @@
+use itertools::Itertools;
+use std::collections::HashMap;
+
+const EXTEND: bool = true;
+
+pub fn day8() {
+    let (antennae, width, height) = input();
+
+    let mut antinodes: Vec<(i64, i64)> = antennae
+        .values()
+        .flat_map(|antennae_set| {
+            antennae_set
+                .iter()
+                .combinations(2)
+                .flat_map(|pair| {
+                    let ((x1, y1), (x2, y2)) = (pair[0], pair[1]);
+                    let (dx, dy) = (x2 - x1, y2 - y1);
+
+                    if EXTEND {
+                        (0..width.max(height))
+                            .flat_map(|i| [(x1 - dx * i, y1 - dy * i), (x1 + dx * i, y1 + dy * i)])
+                            .collect()
+                    } else {
+                        vec![(x1 - dx, y1 - dy), (x2 + dx, y2 + dy)]
+                    }
+                })
+                .collect::<Vec<(i64, i64)>>()
+        })
+        .filter(|(x, y)| *x < width && *y < height && *x >= 0 && *y >= 0)
+        .collect();
+    antinodes.sort();
+    antinodes.dedup();
+
+    println!("Unique Antinodes: {}", antinodes.len());
+}
+
+fn input() -> (HashMap<char, Vec<(i64, i64)>>, i64, i64) {
+    let input = crate::input(8);
+
+    let unsorted_antennae = input.lines().enumerate().flat_map(|(y, line)| {
+        line.chars()
+            .enumerate()
+            .filter(|(_, c)| *c != '.')
+            .map(move |(x, c)| (c, (x as i64, y as i64)))
+    });
+
+    let mut antennae = HashMap::<char, Vec<(i64, i64)>>::new();
+    for (c, p) in unsorted_antennae {
+        antennae.entry(c).or_default().push(p);
+    }
+
+    (
+        antennae,
+        input.lines().nth(0).unwrap().len() as i64,
+        input.lines().count() as i64,
+    )
+}

src/main.rs

@@ -1,12 +1,21 @@
+#[allow(dead_code)]
 mod day1;
+#[allow(dead_code)]
 mod day2;
+#[allow(dead_code)]
 mod day3;
+#[allow(dead_code)]
 mod day4;
+#[allow(dead_code)]
 mod day5;
+#[allow(dead_code)]
 mod day6;
+#[allow(dead_code)]
+mod day7;
+mod day8;
 
 fn main() {
-    day6::day6();
+    day8::day8();
 }
 
 pub fn input(day: u8) -> String {