From bd581c2faccf0553d6ce233378b4580f21281e41 Mon Sep 17 00:00:00 2001 From: Ben C Date: Mon, 8 Dec 2025 11:28:36 -0500 Subject: [PATCH] Use crane and stuff --- Cargo.toml | 7 +- advent_core/src/lib.rs | 2 +- advent_core/src/parser.rs | 2 +- advent_core/src/year.rs | 2 +- flake.lock | 112 +++++++++++++++++++++++++++- flake.nix | 150 ++++++++++++++++++++++++++++++-------- macros/Cargo.toml | 2 +- utils/src/grid.rs | 2 +- years/2024/src/day_1.rs | 43 +++++------ years/2024/src/day_11.rs | 12 ++- years/2024/src/day_12.rs | 2 +- years/2024/src/day_17.rs | 8 +- years/2024/src/day_2.rs | 49 +++++++++---- years/2024/src/day_20.rs | 10 +-- years/2024/src/day_22.rs | 4 +- years/2024/src/day_24.rs | 10 +-- years/2024/src/day_3.rs | 25 ++++--- years/2024/src/day_5.rs | 77 +++++++++++-------- years/2024/src/day_9.rs | 10 +-- years/2025/src/day_1.rs | 2 +- years/2025/src/day_10.rs | 4 +- years/2025/src/day_11.rs | 4 +- years/2025/src/day_12.rs | 4 +- years/2025/src/day_2.rs | 2 +- years/2025/src/day_3.rs | 2 +- years/2025/src/day_4.rs | 2 +- years/2025/src/day_5.rs | 2 +- years/2025/src/day_6.rs | 12 +-- years/2025/src/day_7.rs | 2 +- years/2025/src/day_8.rs | 17 ++--- years/2025/src/day_9.rs | 4 +- 31 files changed, 393 insertions(+), 193 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 4371e9b..489214e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -5,12 +5,7 @@ edition = "2021" [workspace] -members = [ - "advent_core", - "macros", - "utils", - "years/*" -] +members = ["advent_core", "macros", "utils", "years/*"] # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html diff --git a/advent_core/src/lib.rs b/advent_core/src/lib.rs index 33fd4d7..8733a7d 100644 --- a/advent_core/src/lib.rs +++ b/advent_core/src/lib.rs @@ -7,5 +7,5 @@ pub const MAX_DAY: usize = 25; pub use bootstrap::make_year; pub use day::Day; -pub use parser::{DP, Selection, YDP, get_dp_and_input, get_ydp_and_input}; +pub use parser::{get_dp_and_input, get_ydp_and_input, Selection, DP, YDP}; pub use year::Year; diff --git a/advent_core/src/parser.rs b/advent_core/src/parser.rs index 3090299..940dd34 100644 --- a/advent_core/src/parser.rs +++ b/advent_core/src/parser.rs @@ -1,6 +1,6 @@ use std::env::args; use std::fs; -use std::io::{Read, stdin}; +use std::io::{stdin, Read}; #[derive(Clone, Debug)] pub enum Selection { diff --git a/advent_core/src/year.rs b/advent_core/src/year.rs index 633954d..54b4afc 100644 --- a/advent_core/src/year.rs +++ b/advent_core/src/year.rs @@ -1,4 +1,4 @@ -use crate::parser::{DP, Selection}; +use crate::parser::{Selection, DP}; use super::MAX_DAY; diff --git a/flake.lock b/flake.lock index e8ed413..5a3f88e 100644 --- a/flake.lock +++ b/flake.lock @@ -1,12 +1,96 @@ { "nodes": { + "crane": { + "locked": { + "lastModified": 1765145449, + "narHash": "sha256-aBVHGWWRzSpfL++LubA0CwOOQ64WNLegrYHwsVuVN7A=", + "owner": "ipetkov", + "repo": "crane", + "rev": "69f538cdce5955fcd47abfed4395dc6d5194c1c5", + "type": "github" + }, + "original": { + "owner": "ipetkov", + "repo": "crane", + "type": "github" + } + }, + "fenix": { + "inputs": { + "nixpkgs": "nixpkgs", + "rust-analyzer-src": "rust-analyzer-src" + }, + "locked": { + "lastModified": 1765003156, + "narHash": "sha256-k4YrPUhRj7Ciq385vREU57RHiDFycY5RaJwdCOmsLhU=", + "owner": "nix-community", + "repo": "fenix", + "rev": "e8361cc010853d17740a63aae00385061ac9de51", + "type": "github" + }, + "original": { + "owner": "nix-community", + "repo": "fenix", + "type": "github" + } + }, + "flakelight": { + "inputs": { + "nixpkgs": "nixpkgs_2" + }, + "locked": { + "lastModified": 1765198385, + "narHash": "sha256-pFzfw2g98QdI69IUueBWx/peDG+HGnToelHXHS82p/8=", + "owner": "nix-community", + "repo": "flakelight", + "rev": "b6028a5af905d29cfc20fa80e0eac915c840f9a8", + "type": "github" + }, + "original": { + "owner": "nix-community", + "repo": "flakelight", + "type": "github" + } + }, "nixpkgs": { "locked": { - "lastModified": 1732937961, - "narHash": "sha256-B5pYT+IVaqcrfOekkwKvx/iToDnuQWzc2oyDxzzBDc4=", + "lastModified": 1764667669, + "narHash": "sha256-7WUCZfmqLAssbDqwg9cUDAXrSoXN79eEEq17qhTNM/Y=", + "owner": "nixos", + "repo": "nixpkgs", + "rev": "418468ac9527e799809c900eda37cbff999199b6", + "type": "github" + }, + "original": { + "owner": "nixos", + "ref": "nixos-unstable", + "repo": "nixpkgs", + "type": "github" + } + }, + "nixpkgs_2": { + "locked": { + "lastModified": 1764950072, + "narHash": "sha256-BmPWzogsG2GsXZtlT+MTcAWeDK5hkbGRZTeZNW42fwA=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "f61125a668a320878494449750330ca58b78c557", + "type": "github" + }, + "original": { + "owner": "NixOS", + "ref": "nixos-unstable", + "repo": "nixpkgs", + "type": "github" + } + }, + "nixpkgs_3": { + "locked": { + "lastModified": 1764947035, + "narHash": "sha256-EYHSjVM4Ox4lvCXUMiKKs2vETUSL5mx+J2FfutM7T9w=", "owner": "nixos", "repo": "nixpkgs", - "rev": "4703b8d2c708e13a8cab03d865f90973536dcdf5", + "rev": "a672be65651c80d3f592a89b3945466584a22069", "type": "github" }, "original": { @@ -18,7 +102,27 @@ }, "root": { "inputs": { - "nixpkgs": "nixpkgs" + "crane": "crane", + "fenix": "fenix", + "flakelight": "flakelight", + "nixpkgs": "nixpkgs_3" + } + }, + "rust-analyzer-src": { + "flake": false, + "locked": { + "lastModified": 1764925941, + "narHash": "sha256-zldc1SrUIhGMdQp+0woSqvBS51Mi8PW6JukONBQXZBY=", + "owner": "rust-lang", + "repo": "rust-analyzer", + "rev": "2cbf3587d36dfc7b701ebb744d3dd5064355d04f", + "type": "github" + }, + "original": { + "owner": "rust-lang", + "ref": "nightly", + "repo": "rust-analyzer", + "type": "github" } } }, diff --git a/flake.nix b/flake.nix index 3ec4dbd..345107f 100644 --- a/flake.nix +++ b/flake.nix @@ -1,41 +1,129 @@ { - inputs.nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable"; + inputs = { + nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable"; + flakelight.url = "github:nix-community/flakelight"; + crane.url = "github:ipetkov/crane"; + fenix.url = "github:nix-community/fenix"; + }; outputs = { self, nixpkgs, + flakelight, + crane, + fenix, }: let - forAllSystems = nixpkgs.lib.genAttrs [ - "aarch64-linux" - "aarch64-darwin" - "x86_64-darwin" - "x86_64-linux" - ]; - pkgsFor = system: import nixpkgs {inherit system;}; - in { - packages = - forAllSystems - (system: let - pkgs = pkgsFor system; - in { - default = pkgs.rustPlatform.buildRustPackage { - pname = "advent"; - version = "0.1.0"; - src = ./.; - cargoLock.lockFile = ./Cargo.lock; + inherit (nixpkgs) lib; + selectToolchain = fenix: fenix.complete; + mkCrane = pkgs: let + inherit (selectToolchain pkgs.fenix) toolchain; + craneLib = (crane.mkLib nixpkgs.legacyPackages.${pkgs.system}).overrideToolchain toolchain; + rawSrc = ./.; + src = lib.fileset.toSource { + root = rawSrc; + fileset = lib.fileset.unions [ + ./advent_core + ./src + ./macros + ./utils + ./years + ./Cargo.lock + ./Cargo.toml + ]; + }; + commonArgs = { + inherit src; + strictDeps = true; + }; + cargoArtifacts = craneLib.buildDepsOnly commonArgs; + individualCrateArgs = + commonArgs + // { + inherit cargoArtifacts src; + inherit (craneLib.crateNameFromCargoToml {inherit src;}) version; + # NB: we disable tests since we'll run them all via cargo-nextest + doCheck = false; }; - }); - devShells = forAllSystems: ( - system: let - pkgs = pkgsFor system; + buildCrate = pname: + craneLib.buildPackage ( + individualCrateArgs + // { + inherit pname; + cargoExtraArgs = "-p ${pname}"; + } + ); + in { + inherit + craneLib + src + commonArgs + cargoArtifacts + individualCrateArgs + buildCrate + ; + }; + years = builtins.attrNames (lib.filterAttrs (_: v: v == "directory") (builtins.readDir ./years)); + allCrates = + (builtins.map (y: "y_${y}") years) + ++ [ + "advent" + "advent_core" + "utils" + "macros" + ]; + forAllCrates = lib.genAttrs' allCrates; + in + flakelight ./. { + lib = { + inherit years allCrates; + }; + nixpkgs.overlays = [fenix.overlays.default]; + flakelight.builtinFormatters = false; + formatters = pkgs: let + alejandra = "${pkgs.lib.getExe pkgs.alejandra} ."; + rustfmt = "${(selectToolchain pkgs.fenix).rustfmt}/bin/rustfmt ."; + taplo = "${pkgs.lib.getExe pkgs.taplo} fmt ."; in { - default = pkgs.mkShell { - packages = with pkgs; [ - cargo - just - ]; + "*.nix" = alejandra; + "*.rs" = rustfmt; + "*.toml" = taplo; + }; + packages = + forAllCrates (name: { + inherit name; + value = pkgs: (mkCrane pkgs).buildCrate name; + }) + // { + default = pkgs: (mkCrane pkgs).buildCrate "advent"; }; - } - ); - }; + checks = pkgs: let + inherit (mkCrane pkgs) commonArgs craneLib cargoArtifacts; + in + forAllCrates (name: { + name = "clippy-${name}"; + value = craneLib.cargoClippy ( + commonArgs + // { + inherit cargoArtifacts; + cargoClippyExtraArgs = "--all-targets -p ${name} -- --deny warnings"; + } + ); + }) + // forAllCrates (name: { + name = "nextest-${name}"; + value = craneLib.cargoNextest ( + commonArgs + // { + inherit cargoArtifacts; + partitions = 1; + partitionType = "count"; + cargoNextestPartitionsExtraArgs = "--no-tests=pass -p ${name}"; + } + ); + }); + devShell = pkgs: + (mkCrane pkgs).craneLib.devShell { + checks = self.checks.${pkgs.system}; + }; + }; } diff --git a/macros/Cargo.toml b/macros/Cargo.toml index aae4755..4883d5a 100644 --- a/macros/Cargo.toml +++ b/macros/Cargo.toml @@ -9,4 +9,4 @@ edition = "2021" proc-macro = true [dependencies] -advent_core = { path = "../advent_core" } \ No newline at end of file +advent_core = { path = "../advent_core" } diff --git a/utils/src/grid.rs b/utils/src/grid.rs index 8379e4f..55538d0 100644 --- a/utils/src/grid.rs +++ b/utils/src/grid.rs @@ -157,7 +157,7 @@ impl Grid { } /// Obtain a mutable reference to a tile in the grid - pub fn get_mut<'a>(&'a mut self, pos: Position) -> Option<&'a mut T> { + pub fn get_mut(&mut self, pos: Position) -> Option<&mut T> { self.data .get_mut(pos.y as usize) .and_then(|row| row.get_mut(pos.x as usize)) diff --git a/years/2024/src/day_1.rs b/years/2024/src/day_1.rs index fb69760..fce1c0c 100644 --- a/years/2024/src/day_1.rs +++ b/years/2024/src/day_1.rs @@ -1,10 +1,9 @@ -use advent_core::{Day, day_stuff, ex_for_day}; +use advent_core::{day_stuff, ex_for_day, Day}; use utils::misc::counts; pub struct Day1; impl Day for Day1 { - day_stuff!(1, "11", "31", (Vec, Vec)); fn part_1(input: Self::Input) -> Option { @@ -12,33 +11,35 @@ impl Day for Day1 { l.sort_unstable(); r.sort_unstable(); - Some(l.into_iter() - .zip(r) - .map(|(l, r)| (l - r).abs()) - .sum::() - .to_string() + Some( + l.into_iter() + .zip(r) + .map(|(l, r)| (l - r).abs()) + .sum::() + .to_string(), ) } fn part_2(input: Self::Input) -> Option { let (l, r) = input; let apr = counts(r.into_iter()); - Some(l.into_iter() - .map(|l| - l as u64 * apr.get(&l).unwrap_or(&0) - ) - .sum::() - .to_string() + Some( + l.into_iter() + .map(|l| l as u64 * apr.get(&l).unwrap_or(&0)) + .sum::() + .to_string(), ) } - + fn parse_input(input: &str) -> Self::Input { - input.split("\n").map(|line| { - let mut split = line.trim().split_ascii_whitespace(); - let left = split.next().unwrap().parse::().unwrap(); - let right = split.next().unwrap().parse::().unwrap(); - (left, right) - }).collect() + input + .split("\n") + .map(|line| { + let mut split = line.trim().split_ascii_whitespace(); + let left = split.next().unwrap().parse::().unwrap(); + let right = split.next().unwrap().parse::().unwrap(); + (left, right) + }) + .collect() } - } diff --git a/years/2024/src/day_11.rs b/years/2024/src/day_11.rs index 429de95..cbf5de4 100644 --- a/years/2024/src/day_11.rs +++ b/years/2024/src/day_11.rs @@ -20,14 +20,12 @@ pub fn do_blinks(stones: Vec, blinks: usize) -> usize { for (num, count) in stone_map { if num == 0 { *new_map.entry(1).or_insert(0) += count; + } else if num_digits(num).is_multiple_of(2) { + let (left, right) = split_num_once(num); + *new_map.entry(left).or_insert(0) += count; + *new_map.entry(right).or_insert(0) += count; } else { - if num_digits(num) % 2 == 0 { - let (left, right) = split_num_once(num); - *new_map.entry(left).or_insert(0) += count; - *new_map.entry(right).or_insert(0) += count; - } else { - *new_map.entry(num * 2024).or_insert(0) += count; - } + *new_map.entry(num * 2024).or_insert(0) += count; } } diff --git a/years/2024/src/day_12.rs b/years/2024/src/day_12.rs index 69d60a0..39031ac 100644 --- a/years/2024/src/day_12.rs +++ b/years/2024/src/day_12.rs @@ -19,7 +19,7 @@ fn trace_perim( ) -> (usize, HashSet) { let mut perims = HashSet::with_capacity(100); let mut turns = 0; - let mut curs = GridCursor::new(&grid, starting_pos, initial_dir); + let mut curs = GridCursor::new(grid, starting_pos, initial_dir); let mut init = false; while (curs.pos, curs.dir) != (starting_pos, initial_dir) || !init { diff --git a/years/2024/src/day_17.rs b/years/2024/src/day_17.rs index b728fdd..fbba92d 100644 --- a/years/2024/src/day_17.rs +++ b/years/2024/src/day_17.rs @@ -10,7 +10,7 @@ pub struct Registers { } impl Registers { - fn from_combo_op(&self, combo_op: &ComboOperand) -> u128 { + fn with_combo_op(&self, combo_op: &ComboOperand) -> u128 { match combo_op { ComboOperand::RegA => self.a, ComboOperand::RegB => self.b, @@ -44,7 +44,7 @@ impl ComboOperand { match self { Self::Literal(v) => *v, Self::Reserved => panic!(), - reg => regs.from_combo_op(reg), + reg => regs.with_combo_op(reg), } } } @@ -85,7 +85,7 @@ impl Instruction { regs.a /= 2_u128.pow(op.get_val(regs) as u32); } Self::Bxl(v) => { - regs.b = regs.b ^ v; + regs.b ^= v; } Self::Bst(op) => { regs.b = op.get_val(regs) % 8; @@ -96,7 +96,7 @@ impl Instruction { } } Self::Bxc(_) => { - regs.b = regs.b ^ regs.c; + regs.b ^= regs.c; } Self::Out(op) => { return (ip + 2, Some(op.get_val(regs) % 8)); diff --git a/years/2024/src/day_2.rs b/years/2024/src/day_2.rs index 073ebe8..84a0a6e 100644 --- a/years/2024/src/day_2.rs +++ b/years/2024/src/day_2.rs @@ -1,34 +1,53 @@ - -use advent_core::{Day, day_stuff, ex_for_day}; +use advent_core::{day_stuff, ex_for_day, Day}; use utils::misc::{all_combos_remove_one, follows_diff_range, FollowRangeResult}; pub struct Day2; fn line_valid(line: &[i64]) -> bool { let res = follows_diff_range(line, -3..4, true, false); - matches!(res, FollowRangeResult::Increasing | FollowRangeResult::Decreasing) + matches!( + res, + FollowRangeResult::Increasing | FollowRangeResult::Decreasing + ) } impl Day for Day2 { - day_stuff!(2, "2", "4", Vec>); fn part_1(input: Self::Input) -> Option { - Some(input.into_iter().filter(|v| line_valid(v)).count().to_string()) + Some( + input + .into_iter() + .filter(|v| line_valid(v)) + .count() + .to_string(), + ) } fn part_2(input: Self::Input) -> Option { - Some(input.into_iter().filter(|line| { - line_valid(line) || - all_combos_remove_one(line) - .any(|combo| { - let v = combo.copied().collect::>(); - line_valid(&v) - }) - }).count().to_string()) + Some( + input + .into_iter() + .filter(|line| { + line_valid(line) + || all_combos_remove_one(line).any(|combo| { + let v = combo.copied().collect::>(); + line_valid(&v) + }) + }) + .count() + .to_string(), + ) } - + fn parse_input(input: &str) -> Self::Input { - input.split('\n').map(|l| l.split_ascii_whitespace().map(|x| x.parse::().unwrap()).collect()).collect() + input + .split('\n') + .map(|l| { + l.split_ascii_whitespace() + .map(|x| x.parse::().unwrap()) + .collect() + }) + .collect() } } diff --git a/years/2024/src/day_20.rs b/years/2024/src/day_20.rs index a117dc2..51e2064 100644 --- a/years/2024/src/day_20.rs +++ b/years/2024/src/day_20.rs @@ -28,8 +28,7 @@ impl Day for Day20 { costs.insert(curs, cost); let (_, next_pos, _) = input .relatives(curs, &CARDINALS) - .filter(|(_, p, t)| **t != Tile::Wall && !costs.contains_key(p)) - .next() + .find(|(_, p, t)| **t != Tile::Wall && !costs.contains_key(p)) .unwrap(); curs = next_pos; cost += 1; @@ -41,7 +40,7 @@ impl Day for Day20 { for (pos_b, cost_b) in costs.iter() { if cost_b < cost_a { let diff = *cost_a - *cost_b; - let dist = pos_a.manhattan(&pos_b).abs() as usize; + let dist = pos_a.manhattan(pos_b).unsigned_abs(); if dist <= 2 { cheat_set.insert((*pos_a, *pos_b), diff - dist); } @@ -64,8 +63,7 @@ impl Day for Day20 { costs.insert(curs, cost); let (_, next_pos, _) = input .relatives(curs, &CARDINALS) - .filter(|(_, p, t)| **t != Tile::Wall && !costs.contains_key(p)) - .next() + .find(|(_, p, t)| **t != Tile::Wall && !costs.contains_key(p)) .unwrap(); curs = next_pos; cost += 1; @@ -77,7 +75,7 @@ impl Day for Day20 { for (pos_b, cost_b) in costs.iter() { if cost_b < cost_a { let diff = *cost_a - *cost_b; - let dist = pos_a.manhattan(&pos_b).abs() as usize; + let dist = pos_a.manhattan(pos_b).unsigned_abs(); if dist <= 20 { cheat_set.insert((*pos_a, *pos_b), diff - dist); } diff --git a/years/2024/src/day_22.rs b/years/2024/src/day_22.rs index 2dabb45..26ddd2d 100644 --- a/years/2024/src/day_22.rs +++ b/years/2024/src/day_22.rs @@ -35,9 +35,7 @@ fn get_all_four_unique_changes(init: usize, times: usize) -> HashMap<[isize; 4], .fold(HashMap::with_capacity(times / 4), |mut acc, w| { let changes = [w[0].0, w[1].0, w[2].0, w[3].0]; let final_val = w[3].1; - if !acc.contains_key(&changes) { - acc.insert(changes, final_val); - } + acc.entry(changes).or_insert(final_val); acc }) } diff --git a/years/2024/src/day_24.rs b/years/2024/src/day_24.rs index adbe3bd..bcabc58 100644 --- a/years/2024/src/day_24.rs +++ b/years/2024/src/day_24.rs @@ -42,7 +42,7 @@ impl Gate { let lhs = s.next().unwrap().to_string(); let op = s.next().unwrap(); let rhs = s.next().unwrap().to_string(); - let target = s.skip(1).next().unwrap().to_string(); + let target = s.nth(1).unwrap().to_string(); let op = match op { "AND" => Op::And, "OR" => Op::Or, @@ -134,7 +134,7 @@ fn test_first_adder(gates: &Gates) -> AdderTestResult { // #2 & #5, ^ // #4 & #5, ^ // -fn test_adder(num: usize, carry_input: &String, gates: &Gates) -> AdderTestResult { +fn test_adder(num: usize, carry_input: &str, gates: &Gates) -> AdderTestResult { let x = format!("x{num:02}"); let y = format!("y{num:02}"); let z = format!("z{num:02}"); @@ -153,7 +153,7 @@ fn test_adder(num: usize, carry_input: &String, gates: &Gates) -> AdderTestResul ) { if let Some(Gate { target: z_target, .. - }) = find_gate(gates, &carry_input, xy_xor_target.as_str(), Op::Xor) + }) = find_gate(gates, carry_input, xy_xor_target.as_str(), Op::Xor) { if *z_target != z { // We know gate #3 is pointing to the wrong target, as it should be pointing to z[] @@ -173,10 +173,10 @@ fn test_adder(num: usize, carry_input: &String, gates: &Gates) -> AdderTestResul // From here we've checked all test cases, we can confidently attempt to find the carry // output now - let carry_xy_target = &find_gate(&gates, xy_xor_target, &carry_input, Op::And) + let carry_xy_target = &find_gate(gates, xy_xor_target, carry_input, Op::And) .expect("Failed to find carry_xy_target") .target; - let carry_out = &find_gate(&gates, carry_xy_target, xy_and_target, Op::Or) + let carry_out = &find_gate(gates, carry_xy_target, xy_and_target, Op::Or) .expect("Failed to find carry_out") .target; if *carry_out == format!("z{:02}", num + 1) { diff --git a/years/2024/src/day_3.rs b/years/2024/src/day_3.rs index 1dfdf4f..5347228 100644 --- a/years/2024/src/day_3.rs +++ b/years/2024/src/day_3.rs @@ -1,5 +1,4 @@ - -use advent_core::{Day, day_stuff, ex_for_day}; +use advent_core::{day_stuff, ex_for_day, Day}; use regex::RegexBuilder; pub struct Day3; @@ -8,15 +7,15 @@ const RE: &str = r"mul\((\d+),(\d+)\)"; fn re_do(i: &str) -> u64 { let re = RegexBuilder::new(RE).multi_line(true).build().unwrap(); - re.captures_iter(i).map(|c| { - c.get(1).unwrap().as_str().parse::().unwrap() - * - c.get(2).unwrap().as_str().parse::().unwrap() - }).sum::() + re.captures_iter(i) + .map(|c| { + c.get(1).unwrap().as_str().parse::().unwrap() + * c.get(2).unwrap().as_str().parse::().unwrap() + }) + .sum::() } impl Day for Day3 { - day_stuff!(3, "161", "48"); fn part_1(input: Self::Input) -> Option { @@ -24,8 +23,12 @@ impl Day for Day3 { } fn part_2(input: Self::Input) -> Option { - Some(input.split("do()").map(|v| - re_do(v.split("don't()").nth(0).unwrap()) - ).sum::().to_string()) + Some( + input + .split("do()") + .map(|v| re_do(v.split("don't()").nth(0).unwrap())) + .sum::() + .to_string(), + ) } } diff --git a/years/2024/src/day_5.rs b/years/2024/src/day_5.rs index d8d4640..8c84b7a 100644 --- a/years/2024/src/day_5.rs +++ b/years/2024/src/day_5.rs @@ -1,23 +1,31 @@ - use std::collections::{HashMap, HashSet}; -use advent_core::{Day, day_stuff, ex_for_day}; +use advent_core::{day_stuff, ex_for_day, Day}; pub struct Day5; #[derive(Clone, Debug)] -pub struct Rules(HashMap>); +pub struct Rules(HashMap>); impl Rules { pub fn take(&mut self, lhs: i64, rhs: i64) { - self.0.entry(lhs).and_modify(|seen| { seen.push(rhs); }).or_insert(vec![rhs]); + self.0 + .entry(lhs) + .and_modify(|seen| { + seen.push(rhs); + }) + .or_insert(vec![rhs]); } fn good(&self, up: &[i64]) -> bool { let mut seen = HashSet::new(); for u in up.iter() { - if self.0.get(u).is_none_or(|should| should.iter().all(|s| !seen.contains(s))) { - seen.insert(*u); + if self + .0 + .get(u) + .is_none_or(|should| should.iter().all(|s| !seen.contains(s))) + { + seen.insert(*u); } else { return false; } @@ -25,52 +33,57 @@ impl Rules { true } - fn sort_to_rules(&self, up: &mut[i64]) { + fn sort_to_rules(&self, up: &mut [i64]) { while !self.good(up) { self.sort_step(up); } } - fn sort_step(&self, up: &mut[i64]) { - for i in 0..up.len()-1 { - for j in i+1..up.len() { + fn sort_step(&self, up: &mut [i64]) { + for i in 0..up.len() - 1 { + for j in i + 1..up.len() { if self.0.get(&up[j]).is_some_and(|shld| shld.contains(&up[i])) { up.swap(i, j); - } + } } } } } impl Day for Day5 { - day_stuff!(5, "143", "123", (Rules, Vec>)); fn part_1(input: Self::Input) -> Option { let (rules, updates) = input; - let ans = updates.into_iter().filter_map(|up| { - if rules.good(&up) { - Some(up[up.len() / 2]) - } else { - None - } - }).sum::(); + let ans = updates + .into_iter() + .filter_map(|up| { + if rules.good(&up) { + Some(up[up.len() / 2]) + } else { + None + } + }) + .sum::(); Some(ans.to_string()) } fn part_2(input: Self::Input) -> Option { let (rules, updates) = input; - let ans = updates.into_iter().filter_map(|mut up| { - if !rules.good(&up) { - rules.sort_to_rules(&mut up); - Some(up[up.len() / 2]) - } else { - None - } - }).sum::(); + let ans = updates + .into_iter() + .filter_map(|mut up| { + if !rules.good(&up) { + rules.sort_to_rules(&mut up); + Some(up[up.len() / 2]) + } else { + None + } + }) + .sum::(); Some(ans.to_string()) } - + fn parse_input(input: &str) -> Self::Input { let (rules, updates) = input.split_once("\n\n").unwrap(); let mut rules_o = Rules(HashMap::with_capacity(50)); @@ -78,6 +91,12 @@ impl Day for Day5 { let (lhs, rhs) = l.split_once('|').unwrap(); rules_o.take(lhs.parse().unwrap(), rhs.parse().unwrap()); } - (rules_o, updates.split('\n').map(|l| l.split(',').map(|x| x.parse().unwrap()).collect()).collect()) + ( + rules_o, + updates + .split('\n') + .map(|l| l.split(',').map(|x| x.parse().unwrap()).collect()) + .collect(), + ) } } diff --git a/years/2024/src/day_9.rs b/years/2024/src/day_9.rs index ff93079..7498cf2 100644 --- a/years/2024/src/day_9.rs +++ b/years/2024/src/day_9.rs @@ -107,11 +107,10 @@ impl Day for Day9 { loop { if let (Block::File(_), _) = input.data[i] { let next_blank = input.iter_blanks_before(i).next(); - if let Some((j, _)) = next_blank { - if input.swap_blocks(i, j) { + if let Some((j, _)) = next_blank + && input.swap_blocks(i, j) { i += 1; } - } } if i == 0 { break; @@ -131,11 +130,10 @@ impl Day for Day9 { let next_blank = input .iter_blanks_before(i) .find(|(_, b_amnt)| *b_amnt >= size); - if let Some((j, _)) = next_blank { - if input.swap_blocks(i, j) { + if let Some((j, _)) = next_blank + && input.swap_blocks(i, j) { i += 1; } - } } if i == 0 { break; diff --git a/years/2025/src/day_1.rs b/years/2025/src/day_1.rs index f980938..54940e8 100644 --- a/years/2025/src/day_1.rs +++ b/years/2025/src/day_1.rs @@ -1,4 +1,4 @@ -use advent_core::{Day, day_stuff, ex_for_day}; +use advent_core::{day_stuff, ex_for_day, Day}; pub struct Day1; diff --git a/years/2025/src/day_10.rs b/years/2025/src/day_10.rs index 4ebac25..68e638c 100644 --- a/years/2025/src/day_10.rs +++ b/years/2025/src/day_10.rs @@ -1,10 +1,8 @@ - -use advent_core::{Day, day_stuff, ex_for_day}; +use advent_core::{day_stuff, ex_for_day, Day}; pub struct Day10; impl Day for Day10 { - day_stuff!(10, "", ""); fn part_1(_input: Self::Input) -> Option { diff --git a/years/2025/src/day_11.rs b/years/2025/src/day_11.rs index 95063da..46d6808 100644 --- a/years/2025/src/day_11.rs +++ b/years/2025/src/day_11.rs @@ -1,10 +1,8 @@ - -use advent_core::{Day, day_stuff, ex_for_day}; +use advent_core::{day_stuff, ex_for_day, Day}; pub struct Day11; impl Day for Day11 { - day_stuff!(11, "", ""); fn part_1(_input: Self::Input) -> Option { diff --git a/years/2025/src/day_12.rs b/years/2025/src/day_12.rs index 9c1d59f..eef8ad6 100644 --- a/years/2025/src/day_12.rs +++ b/years/2025/src/day_12.rs @@ -1,10 +1,8 @@ - -use advent_core::{Day, day_stuff, ex_for_day}; +use advent_core::{day_stuff, ex_for_day, Day}; pub struct Day12; impl Day for Day12 { - day_stuff!(12, "", ""); fn part_1(_input: Self::Input) -> Option { diff --git a/years/2025/src/day_2.rs b/years/2025/src/day_2.rs index c94758d..b384a2f 100644 --- a/years/2025/src/day_2.rs +++ b/years/2025/src/day_2.rs @@ -1,6 +1,6 @@ use std::ops::RangeInclusive; -use advent_core::{Day, day_stuff, ex_for_day}; +use advent_core::{day_stuff, ex_for_day, Day}; use utils::num::{num_digits, split_num_at, split_num_once}; pub struct Day2; diff --git a/years/2025/src/day_3.rs b/years/2025/src/day_3.rs index a99b607..719c74f 100644 --- a/years/2025/src/day_3.rs +++ b/years/2025/src/day_3.rs @@ -1,4 +1,4 @@ -use advent_core::{Day, day_stuff, ex_for_day}; +use advent_core::{day_stuff, ex_for_day, Day}; pub struct Day3; diff --git a/years/2025/src/day_4.rs b/years/2025/src/day_4.rs index 72acc5f..494fa4b 100644 --- a/years/2025/src/day_4.rs +++ b/years/2025/src/day_4.rs @@ -1,4 +1,4 @@ -use advent_core::{Day, day_stuff, ex_for_day}; +use advent_core::{day_stuff, ex_for_day, Day}; use utils::{dir::ALL_8, tiles}; pub struct Day4; diff --git a/years/2025/src/day_5.rs b/years/2025/src/day_5.rs index 95be44a..fca5dd2 100644 --- a/years/2025/src/day_5.rs +++ b/years/2025/src/day_5.rs @@ -1,4 +1,4 @@ -use advent_core::{Day, day_stuff, ex_for_day}; +use advent_core::{day_stuff, ex_for_day, Day}; use utils::range::BetterRange; pub struct Day5; diff --git a/years/2025/src/day_6.rs b/years/2025/src/day_6.rs index 6103119..9298c65 100644 --- a/years/2025/src/day_6.rs +++ b/years/2025/src/day_6.rs @@ -1,4 +1,4 @@ -use advent_core::{Day, day_stuff, ex_for_day}; +use advent_core::{day_stuff, ex_for_day, Day}; pub struct Day6; @@ -22,13 +22,7 @@ impl Day for Day6 { .collect::>() }) .collect::>(); - let ops = uno - .iter() - .skip(uno.len() - 1) - .next() - .unwrap() - .split_whitespace() - .collect::>(); + let ops = uno.last().unwrap().split_whitespace().collect::>(); let mut problems = Vec::with_capacity(uno.len()); for i in 0..dos[0].len() { @@ -57,7 +51,7 @@ impl Day for Day6 { fn part_2(input: Self::Input) -> Option { let mut cols: Vec> = vec![]; - for (_, row) in input.lines().enumerate() { + for row in input.lines() { for (j, c) in row.chars().enumerate() { if let Some(r) = cols.get_mut(j) { r.push(c); diff --git a/years/2025/src/day_7.rs b/years/2025/src/day_7.rs index 3af4caa..6ce886a 100644 --- a/years/2025/src/day_7.rs +++ b/years/2025/src/day_7.rs @@ -1,6 +1,6 @@ use std::collections::{HashMap, HashSet, VecDeque}; -use advent_core::{Day, day_stuff, ex_for_day}; +use advent_core::{day_stuff, ex_for_day, Day}; use utils::{dir::Direction, pos::Position, tiles}; pub struct Day7; diff --git a/years/2025/src/day_8.rs b/years/2025/src/day_8.rs index e68aea9..48e74e7 100644 --- a/years/2025/src/day_8.rs +++ b/years/2025/src/day_8.rs @@ -1,6 +1,6 @@ use std::{collections::HashMap, ops::Sub}; -use advent_core::{Day, day_stuff, ex_for_day}; +use advent_core::{day_stuff, ex_for_day, Day}; pub struct Day8; @@ -48,23 +48,16 @@ impl Day for Day8 { let mut counts = circuits .into_iter() - .fold(HashMap::new(), |mut acc, (_, c)| { + .fold(HashMap::with_capacity(input.len()), |mut acc, (_, c)| { *(acc.entry(c).or_insert(0)) += 1; acc }) - .into_iter() - .map(|(_, count)| count) + .into_values() .collect::>(); counts.sort_by(|a, b| a.cmp(b).reverse()); - Some( - counts - .into_iter() - .take(3) - .fold(1, |acc, x| acc * x) - .to_string(), - ) + Some(counts.into_iter().take(3).product::().to_string()) } fn part_2((_amnt, input): Self::Input) -> Option { @@ -99,7 +92,7 @@ impl Day for Day8 { } } - let (a, b) = last_2.unwrap(); + let (a, b) = last_2.expect("Womp womp"); Some((a.0 * b.0).to_string()) } diff --git a/years/2025/src/day_9.rs b/years/2025/src/day_9.rs index f55318f..bee431d 100644 --- a/years/2025/src/day_9.rs +++ b/years/2025/src/day_9.rs @@ -1,10 +1,8 @@ - -use advent_core::{Day, day_stuff, ex_for_day}; +use advent_core::{day_stuff, ex_for_day, Day}; pub struct Day9; impl Day for Day9 { - day_stuff!(9, "", ""); fn part_1(_input: Self::Input) -> Option { -- 2.51.2