advent-of-code 2025.5.0

Solutions to Advent of Code
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

#![allow(clippy::redundant_pub_crate)]
#![allow(unused)]

use std::cell::RefCell;

pub type ResultType = String;

#[derive(Copy, Clone)]
pub enum Part {
    One,
    Two,
}

pub struct Input<'a> {
    pub part: Part,
    pub text: &'a str,
    #[cfg(feature = "visualization")]
    pub visualization: RefCell<String>,
}

#[allow(single_use_lifetimes)]
#[allow(clippy::needless_lifetimes)]
impl<'a> Input<'a> {
    pub const fn is_part_one(&self) -> bool {
        matches!(self.part, Part::One)
    }

    pub const fn is_part_two(&self) -> bool {
        matches!(self.part, Part::Two)
    }

    pub fn part_values<T>(&self, if_part_one: T, if_part_two: T) -> T {
        // See https://github.com/rust-lang/rust/issues/66753 for missing_const_for_fn.
        #![allow(clippy::missing_const_for_fn)]
        match self.part {
            Part::One => if_part_one,
            Part::Two => if_part_two,
        }
    }

    #[cfg(test)]
    #[allow(clippy::missing_const_for_fn)]
    pub fn part_one(text: &'a str) -> Self {
        Self {
            part: Part::One,
            text,
            #[cfg(feature = "visualization")]
            visualization: RefCell::new("".to_string()),
        }
    }

    #[cfg(test)]
    #[allow(clippy::missing_const_for_fn)]
    pub fn part_two(text: &'a str) -> Self {
        Self {
            part: Part::Two,
            text,
            #[cfg(feature = "visualization")]
            visualization: RefCell::new("".to_string()),
        }
    }
}

#[cfg(test)]
macro_rules! test_part_one {
    ($input:tt => $expected:expr) => {
        assert_eq!(solve(&Input::part_one($input)), Ok($expected));
    };
}
#[cfg(test)]
pub(crate) use test_part_one;

#[cfg(test)]
macro_rules! test_part_one_no_allocations {
    ($input:tt => $expected:expr) => {
        #[cfg(feature = "count-allocations")]
        {
            let info = allocation_counter::measure(|| {
                assert_eq!(solve(&Input::part_one($input)), Ok($expected));
            });
            assert_eq!(0, info.count_total);
        }
        #[cfg(not(feature = "count-allocations"))]
        {
            assert_eq!(solve(&Input::part_one($input)), Ok($expected));
        }
    };
}
#[cfg(test)]
pub(crate) use test_part_one_no_allocations;

#[cfg(test)]
macro_rules! test_part_two {
    ($input:tt => $expected:expr) => {
        assert_eq!(solve(&Input::part_two($input)), Ok($expected));
    };
}
#[cfg(test)]
pub(crate) use test_part_two;

#[cfg(test)]
macro_rules! test_part_two_no_allocations {
    ($input:tt => $expected:expr) => {
        #[cfg(feature = "count-allocations")]
        {
            let info = allocation_counter::measure(|| {
                assert_eq!(solve(&Input::part_two($input)), Ok($expected));
            });
            assert_eq!(0, info.count_total);
        }
        #[cfg(not(feature = "count-allocations"))]
        {
            assert_eq!(solve(&Input::part_two($input)), Ok($expected));
        }
    };
}
#[cfg(test)]
pub(crate) use test_part_two_no_allocations;

#[cfg(test)]
macro_rules! test_part_one_error {
    ($input:tt => $expected:expr) => {
        assert_eq!(Err($expected.into()), solve(&Input::part_one($input)));
    };
}
#[cfg(test)]
pub(crate) use test_part_one_error;

#[cfg(test)]
macro_rules! test_part_two_error {
    ($input:tt => $expected:expr) => {
        assert_eq!(Err($expected.into()), solve(&Input::part_two($input)));
    };
}
#[cfg(test)]
pub(crate) use test_part_two_error;

pub fn on_error() -> String {
    "Invalid input".to_string()
}