Cargo.lock

@@ -22,7 +22,6 @@ name = "advent"
 version = "0.1.0"
 dependencies = [
  "dotenvy",
- "itertools",
  "rayon",
  "regex",
  "reqwest",
@@ -587,15 +586,6 @@ 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,7 +5,6 @@ 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

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

@@ -1,57 +0,0 @@
-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,21 +1,12 @@
-#[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() {
-    day8::day8();
+    day6::day6();
 }
 
 pub fn input(day: u8) -> String {