Jan/AoC
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: Jan:9410fae22e1cc954fa59cca2ecb3ae552827cf32
Branches Tags
Jan:master
..
compare: Jan:3740d93f813043f35c7d914fc0bf228ead9542bc
Branches Tags
Jan:master

No commits in common. "9410fae22e1cc954fa59cca2ecb3ae552827cf32" and "3740d93f813043f35c7d914fc0bf228ead9542bc" have entirely different histories.
9410fae22e ... 3740d93f81

5 changed files with 51 additions and 224 deletions
Show Stats Expand all files Collapse all files

24
aoc_2025/src/day1.rs
View File

@ -1,4 +1,4 @@
use crate::{AoC, SimpleDay};
use crate::AoC;
use winnow::{
Parser, Result,
ascii::{digit1, multispace0},
@ -11,9 +11,7 @@ enum Side {
Right(i64),
}
fn day() -> impl SimpleDay {
AoC::new(parse as _, part1 as _, part2 as _)
}
const AOC: AoC<Parsed> = AoC::new(parse, part1, part2);
fn parse(input: String) -> Parsed {
let mut input: &str = input.as_str();
@ -36,7 +34,7 @@ fn parse_right(input: &mut &str) -> Result<Side> {
.parse_next(input)
}
fn part1(input: Parsed) -> String {
fn part1(input: &Parsed) -> String {
let mut res = 0;
let mut pos = 50i64;
for change in input {
@ -51,12 +49,12 @@ fn part1(input: Parsed) -> String {
format!("{res}")
}
fn part2(input: Parsed) -> String {
fn part2(input: &Parsed) -> String {
let input = input
.iter()
.flat_map(|side| match side {
Side::Left(dx) => (0..*dx).map(|_| Side::Left(1)).collect::<Vec<Side>>(),
Side::Right(dx) => (0..*dx).map(|_| Side::Right(1)).collect::<Vec<Side>>(),
Side::Left(dx) => (0..*dx).map(|i| Side::Left(1)).collect::<Vec<Side>>(),
Side::Right(dx) => (0..*dx).map(|i| Side::Right(1)).collect::<Vec<Side>>(),
})
.collect::<Vec<Side>>();
let mut res = 0;
@ -75,13 +73,11 @@ fn part2(input: Parsed) -> String {
#[cfg(test)]
mod tests {
use crate::Day;
use super::*;
#[test]
fn part1_test() {
day().assert1(
AOC.assert1(
"L68
L30
R48
@ -98,12 +94,12 @@ L82",
#[test]
fn part1_solve() {
day().assert1(include_str!("../input/day1.txt"), "982");
AOC.assert1(include_str!("../input/day1.txt"), "982");
}
#[test]
fn part2_test() {
day().assert2(
AOC.assert2(
"L68
L30
R48
@ -120,6 +116,6 @@ L82",
#[test]
fn part2_solve() {
day().assert2(include_str!("../input/day1.txt"), "6106");
AOC.assert2(include_str!("../input/day1.txt"), "6106");
}
}

22
aoc_2025/src/day2.rs
View File

@ -1,4 +1,4 @@
use crate::{AoC, SimpleDay};
use crate::AoC;
use winnow::{
Parser, Result,
ascii::digit1,
@ -7,9 +7,7 @@ use winnow::{
type Parsed = Vec<(u64, u64)>;
fn day() -> impl SimpleDay {
AoC::new(parse as _, part1 as _, part2 as _)
}
const AOC: AoC<Parsed> = AoC::new(parse, part1, part2);
fn parse(input: String) -> Parsed {
let mut input: &str = input.as_str();
@ -22,7 +20,7 @@ fn parse_range(input: &mut &str) -> Result<(u64, u64)> {
separated_pair(digit1.parse_to(), "-", digit1.parse_to()).parse_next(input)
}
fn part1(input: Parsed) -> String {
fn part1(input: &Parsed) -> String {
let res = input
.iter()
.map(|(from, to)| {
@ -38,13 +36,13 @@ fn part1(input: Parsed) -> String {
format!("{res}")
}
fn part2(input: Parsed) -> String {
fn part2(input: &Parsed) -> String {
let res = input
.iter()
.map(|(from, to)| {
(*from..=*to)
.filter(|i| {
let n = i.ilog10() + 1;
let n = (i.ilog10() + 1);
(1..=(n >> 1)).filter(|p| n % p == 0).any(|p| {
(1..(n / p))
.all(|s| i % 10u64.pow(p) == (i / 10u64.pow(p * s)) % 10u64.pow(p))
@ -58,13 +56,11 @@ fn part2(input: Parsed) -> String {
#[cfg(test)]
mod tests {
use crate::Day;
use super::*;
#[test]
fn part1_test() {
day().assert1(
AOC.assert1(
"11-22,95-115,998-1012,1188511880-1188511890,222220-222224,1698522-1698528,446443-446449,38593856-38593862,565653-565659,824824821-824824827,2121212118-2121212124",
"1227775554",
);
@ -72,12 +68,12 @@ mod tests {
#[test]
fn part1_solve() {
day().assert1(include_str!("../input/day2.txt"), "12599655151");
AOC.assert1(include_str!("../input/day2.txt"), "12599655151");
}
#[test]
fn part2_test() {
day().assert2(
AOC.assert2(
"11-22,95-115,998-1012,1188511880-1188511890,222220-222224,1698522-1698528,446443-446449,38593856-38593862,565653-565659,824824821-824824827,2121212118-2121212124",
"4174379265",
);
@ -85,6 +81,6 @@ mod tests {
#[test]
fn part2_solve() {
day().assert2(include_str!("../input/day2.txt"), "20942028255");
AOC.assert2(include_str!("../input/day2.txt"), "20942028255");
}
}

102
aoc_2025/src/day3.rs
View File

@ -1,102 +0,0 @@
use std::iter::Sum;
use crate::{AoC, WinnowDay};
use winnow::{
Parser, Result,
ascii::newline,
combinator::{repeat, terminated},
error::ContextError,
token::one_of,
};
fn day() -> impl WinnowDay {
AoC::new(parse as _, part1 as _, part2 as _)
}
fn parse(input: &mut &str) -> Result<Vec<Vec<usize>>> {
repeat(1.., parse_line).parse_next(input)
}
fn parse_line(input: &mut &str) -> Result<Vec<usize>, ContextError> {
terminated(
repeat(
1..,
one_of(('0'..='9',)).map(|c: char| c.to_string().parse::<usize>().unwrap()),
),
newline,
)
.parse_next(input)
}
fn part1(input: Vec<Vec<usize>>) -> usize {
input.iter().map(joltage(2)).sum()
}
fn part2(input: Vec<Vec<usize>>) -> usize {
input.iter().map(joltage(12)).sum()
}
fn joltage<
'a,
B: IntoIterator<IntoIter = I> + Copy,
I: ExactSizeIterator<Item = &'a N>,
N: Sum<&'a N> + Into<usize> + From<usize> + Copy + Default + 'a,
>(
size: usize,
) -> impl Fn(B) -> N {
move |line| {
(line.into_iter().len() - size..line.into_iter().len())
.fold((0, 0), |(start, val), end| {
line.into_iter()
.enumerate()
.skip(start)
.take(end - start + 1)
.map(|(i, v)| (i + 1, (*v).into() + val * 10))
.reduce(|a, b| if a.1 >= b.1 { a } else { b })
.unwrap()
})
.1
.into()
}
}
#[cfg(test)]
mod tests {
use crate::Day;
use super::*;
#[test]
fn part1_test() {
day().assert1(
"987654321111111
811111111111119
234234234234278
818181911112111
",
"357",
);
}
#[test]
fn part1_solve() {
day().assert1(include_str!("../input/day3.txt"), "17343");
}
#[test]
fn part2_test() {
day().assert2(
"987654321111111
811111111111119
234234234234278
818181911112111
",
"3121910778619",
);
}
#[test]
fn part2_solve() {
day().assert2(include_str!("../input/day3.txt"), "172664333119298");
}
}

91
aoc_2025/src/lib.rs
View File

@ -1,97 +1,36 @@
#![allow(dead_code)]
#![allow(unused)]
use std::fmt::{Debug, Display};
use winnow::Parser;
mod day1;
mod day2;
mod day3;
trait Day {
fn assert1(&self, input: &str, output: &str);
fn assert2(&self, input: &str, output: &str);
struct AoC<T> {
parse: fn(String) -> T,
part1: fn(&T) -> String,
part2: fn(&T) -> String,
}
struct AoC<P, O1, O2> {
parse: P,
part1: O1,
part2: O2,
}
impl<P, O1, O2> AoC<P, O1, O2> {
fn new(parse: P, part1: O1, part2: O2) -> Self {
impl<T> AoC<T> {
const fn new(parse: fn(String) -> T, part1: fn(&T) -> String, part2: fn(&T) -> String) -> Self {
Self {
parse,
part1,
part2,
}
}
}
trait SimpleDay: Day {}
impl<P, O1, O2> SimpleDay for AoC<fn(String) -> P, fn(P) -> O1, fn(P) -> O2>
where
O1: Display,
O2: Display,
{
}
impl<P, O1, O2> Day for AoC<fn(String) -> P, fn(P) -> O1, fn(P) -> O2>
where
O1: Display,
O2: Display,
{
fn assert1(&self, input: &str, output: &str) {
let parsed = (self.parse)(input.to_string());
assert_eq!(format!("{}", (self.part1)(parsed)), output);
let parsed = (self.parse)(input.into());
assert_eq!((self.part1)(&parsed), output);
}
fn assert2(&self, input: &str, output: &str) {
let parsed = (self.parse)(input.to_string());
assert_eq!(format!("{}", (self.part2)(parsed)), output);
}
let parsed = (self.parse)(input.into());
assert_eq!((self.part2)(&parsed), output);
}
trait WinnowDay: Day {}
impl<O, E, O1, O2> WinnowDay
for AoC<for<'a, 'b> fn(&'a mut &'b str) -> Result<O, E>, fn(O) -> O1, fn(O) -> O2>
where
E: Debug,
O1: Display,
O2: Display,
{
}
fn as_parser<O, E>(
func: for<'a, 'b> fn(&'a mut &'b str) -> Result<O, E>,
) -> impl for<'a> Parser<&'a str, O, E>
where
E: Debug,
{
func
}
impl<O, E, O1, O2> Day
for AoC<for<'a, 'b> fn(&'a mut &'b str) -> Result<O, E>, fn(O) -> O1, fn(O) -> O2>
where
E: Debug,
O1: Display,
O2: Display,
{
fn assert1(&self, input: &str, output: &str) {
let mut input = input;
let mut parser = as_parser(self.parse);
let parsed = parser.parse_next(&mut input).unwrap();
assert_eq!(format!("{}", (self.part1)(parsed)), output);
}
fn assert2(&self, input: &str, output: &str) {
let mut input = input;
let mut parser = as_parser(self.parse);
let parsed = parser.parse_next(&mut input).unwrap();
assert_eq!(format!("{}", (self.part2)(parsed)), output);
fn apply(&self, input: &str) {
let parsed = (self.parse)(input.into());
println!("Part 1: {}", (self.part1)(&parsed));
println!("Part 2: {}", (self.part2)(&parsed));
}
}

36
aoc_2025/src/template.rs
View File

@ -1,48 +1,46 @@
use crate::AoC;
use winnow::{Parser, Result};
use crate::{AoC, Day, SimpleDay, WinnowDay};
type Parsed = String;
fn day() -> impl WinnowDay {
AoC::new(parse as _, part1 as _, part2 as _)
const AOC: AoC<Parsed> = AoC::new(parse, part1, part2);
fn parse(input: String) -> Parsed {
let mut input: &str = input.as_str();
String::new()
}
type Parsed = ();
fn parse(input: &mut &str) -> Result<Parsed> {
"".map(|_| ()).parse_next(input)
fn part1(input: &Parsed) -> String {
let res = 0;
format!("{res}")
}
fn part1(input: Parsed) -> usize {
0
}
fn part2(input: Parsed) -> usize {
0
fn part2(input: &Parsed) -> String {
let res = 0;
format!("{res}")
}
#[cfg(test)]
mod tests {
use crate::Day;
use super::*;
#[test]
fn part1_test() {
day().assert1("", "");
AOC.assert1("", "");
}
#[test]
fn part1_solve() {
day().assert1(include_str!("../input/day.txt"), "");
AOC.assert1(include_str!("../input/day1.txt"), "");
}
// #[test]
// fn part2_test() {
// day().assert2("", "");
// AOC.assert2("", "");
// }
// #[test]
// fn part2_solve() {
// day().assert2(include_str!("../input/day.txt"), "");
// AOC.assert2(include_str!("../input/day1.txt"), "");
// }
}