feat: Completed Day 1 YAY

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
-name = "advent_of_code_XXXX"
+name = "advent_of_code_2025"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 [dependencies]
-tokio = {version = "1.41.1", features = ["full"]}
+tokio = { version = "1.48.0", features = ["full"] }

input/day01_test1

@@ -0,0 +1,10 @@
+L68
+L30
+R48
+L5
+R60
+L55
+L1
+L99
+R14
+L82

input/day01_test2

@@ -0,0 +1,10 @@
+L68
+L30
+R48
+L5
+R60
+L55
+L1
+L99
+R14
+L82

src/main.rs

@@ -1,3 +1,6 @@
+// Allow dead code for days not yet implemented
+#![allow(dead_code)]
+
 mod solutions;
 mod utils;
 

src/solutions/day01.rs

@@ -5,16 +5,16 @@ pub struct Day01 {}
 impl Solution for Day01 {
     fn part1(
         &self,
-        _input: &mut Vec<String>,
+        input: &mut Vec<String>,
     ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
+        Ok(Box::new(Day01::count_zeros(input, false)))
     }
 
     fn part2(
         &self,
-        _input: &mut Vec<String>,
+        input: &mut Vec<String>,
     ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
+        Ok(Box::new(Day01::count_zeros(input, true)))
     }
 
     fn get_day(&self) -> u8 {
@@ -22,7 +22,59 @@ impl Solution for Day01 {
     }
 }
 
-impl Day01 {}
+impl Day01 {
+    fn count_zeros(input: &Vec<String>, count_passing: bool) -> usize {
+        // Dial starts at 50
+        let mut pos: i64 = 50;
+        let mut zeros: usize = 0;
+
+        for line in input {
+            let line = line.trim();
+            if line.is_empty() {
+                continue;
+            }
+
+            let mut chars = line.chars();
+            let dir = chars.next().expect("empty line");
+            let dist_str: String = chars.collect::<String>().trim().to_string();
+            let dist: i64 = dist_str.parse().expect("invalid distance number");
+
+            // Count any time that the dial moves past 0.
+            if count_passing {
+                // Count all zeros passed during the move
+                let step = match dir {
+                    'L' | 'l' => -1,
+                    'R' | 'r' => 1,
+                    _ => panic!("invalid direction (must start with L or R): {}", dir),
+                };
+
+                for _ in 0..dist {
+                    pos = (pos + step).rem_euclid(100);
+                    if pos == 0 {
+                        zeros += 1;
+                    }
+                }
+                continue;
+            }
+
+            // Move directly to the new position
+            match dir {
+                'L' | 'l' => {
+                    pos = (pos - dist).rem_euclid(100);
+                }
+                'R' | 'r' => {
+                    pos = (pos + dist).rem_euclid(100);
+                }
+                _ => panic!("invalid direction (must start with L or R): {}", dir),
+            }
+
+            if pos == 0 {
+                zeros += 1;
+            }
+        }
+        zeros
+    }
+}
 
 /// Test from puzzle input
 #[cfg(test)]
@@ -44,7 +96,7 @@ mod test {
             .unwrap()
             .to_string();
 
-        assert_eq!(answer, "Ready");
+        assert_eq!(answer, "3");
     }
 
     #[test]
@@ -61,6 +113,6 @@ mod test {
             .unwrap()
             .to_string();
 
-        assert_eq!(answer, "Ready");
+        assert_eq!(answer, "6");
     }
 }

src/solutions/day13.rs

@@ -1,66 +0,0 @@
-use super::Solution;
-
-pub struct Day13 {}
-
-impl Solution for Day13 {
-    fn part1(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn part2(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn get_day(&self) -> u8 {
-        13
-    }
-}
-
-impl Day13 {}
-
-/// Test from puzzle input
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::*;
-
-    #[test]
-    fn part1() {
-        let challenge = day13::Day13 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part1(
-                utils::get_input(challenge.get_day(), utils::InputType::Test1)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-
-    #[test]
-    fn part2() {
-        let challenge = day13::Day13 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part2(
-                utils::get_input(challenge.get_day(), utils::InputType::Test2)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-}

src/solutions/day14.rs

@@ -1,66 +0,0 @@
-use super::Solution;
-
-pub struct Day14 {}
-
-impl Solution for Day14 {
-    fn part1(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn part2(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn get_day(&self) -> u8 {
-        14
-    }
-}
-
-impl Day14 {}
-
-/// Test from puzzle input
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::*;
-
-    #[test]
-    fn part1() {
-        let challenge = day14::Day14 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part1(
-                utils::get_input(challenge.get_day(), utils::InputType::Test1)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-
-    #[test]
-    fn part2() {
-        let challenge = day14::Day14 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part2(
-                utils::get_input(challenge.get_day(), utils::InputType::Test2)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-}

src/solutions/day15.rs

@@ -1,66 +0,0 @@
-use super::Solution;
-
-pub struct Day15 {}
-
-impl Solution for Day15 {
-    fn part1(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn part2(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn get_day(&self) -> u8 {
-        15
-    }
-}
-
-impl Day15 {}
-
-/// Test from puzzle input
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::*;
-
-    #[test]
-    fn part1() {
-        let challenge = day15::Day15 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part1(
-                utils::get_input(challenge.get_day(), utils::InputType::Test1)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-
-    #[test]
-    fn part2() {
-        let challenge = day15::Day15 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part2(
-                utils::get_input(challenge.get_day(), utils::InputType::Test2)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-}

src/solutions/day16.rs

@@ -1,66 +0,0 @@
-use super::Solution;
-
-pub struct Day16 {}
-
-impl Solution for Day16 {
-    fn part1(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn part2(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn get_day(&self) -> u8 {
-        16
-    }
-}
-
-impl Day16 {}
-
-/// Test from puzzle input
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::*;
-
-    #[test]
-    fn part1() {
-        let challenge = day16::Day16 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part1(
-                utils::get_input(challenge.get_day(), utils::InputType::Test1)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-
-    #[test]
-    fn part2() {
-        let challenge = day16::Day16 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part2(
-                utils::get_input(challenge.get_day(), utils::InputType::Test2)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-}

src/solutions/day17.rs

@@ -1,66 +0,0 @@
-use super::Solution;
-
-pub struct Day17 {}
-
-impl Solution for Day17 {
-    fn part1(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn part2(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn get_day(&self) -> u8 {
-        17
-    }
-}
-
-impl Day17 {}
-
-/// Test from puzzle input
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::*;
-
-    #[test]
-    fn part1() {
-        let challenge = day17::Day17 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part1(
-                utils::get_input(challenge.get_day(), utils::InputType::Test1)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-
-    #[test]
-    fn part2() {
-        let challenge = day17::Day17 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part2(
-                utils::get_input(challenge.get_day(), utils::InputType::Test2)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-}

src/solutions/day18.rs

@@ -1,66 +0,0 @@
-use super::Solution;
-
-pub struct Day18 {}
-
-impl Solution for Day18 {
-    fn part1(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn part2(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn get_day(&self) -> u8 {
-        18
-    }
-}
-
-impl Day18 {}
-
-/// Test from puzzle input
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::*;
-
-    #[test]
-    fn part1() {
-        let challenge = day18::Day18 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part1(
-                utils::get_input(challenge.get_day(), utils::InputType::Test1)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-
-    #[test]
-    fn part2() {
-        let challenge = day18::Day18 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part2(
-                utils::get_input(challenge.get_day(), utils::InputType::Test2)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-}

src/solutions/day19.rs

@@ -1,66 +0,0 @@
-use super::Solution;
-
-pub struct Day19 {}
-
-impl Solution for Day19 {
-    fn part1(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn part2(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn get_day(&self) -> u8 {
-        19
-    }
-}
-
-impl Day19 {}
-
-/// Test from puzzle input
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::*;
-
-    #[test]
-    fn part1() {
-        let challenge = day19::Day19 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part1(
-                utils::get_input(challenge.get_day(), utils::InputType::Test1)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-
-    #[test]
-    fn part2() {
-        let challenge = day19::Day19 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part2(
-                utils::get_input(challenge.get_day(), utils::InputType::Test2)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-}

src/solutions/day20.rs

@@ -1,66 +0,0 @@
-use super::Solution;
-
-pub struct Day20 {}
-
-impl Solution for Day20 {
-    fn part1(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn part2(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn get_day(&self) -> u8 {
-        20
-    }
-}
-
-impl Day20 {}
-
-/// Test from puzzle input
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::*;
-
-    #[test]
-    fn part1() {
-        let challenge = day20::Day20 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part1(
-                utils::get_input(challenge.get_day(), utils::InputType::Test1)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-
-    #[test]
-    fn part2() {
-        let challenge = day20::Day20 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part2(
-                utils::get_input(challenge.get_day(), utils::InputType::Test2)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-}

src/solutions/day21.rs

@@ -1,66 +0,0 @@
-use super::Solution;
-
-pub struct Day21 {}
-
-impl Solution for Day21 {
-    fn part1(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn part2(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn get_day(&self) -> u8 {
-        21
-    }
-}
-
-impl Day21 {}
-
-/// Test from puzzle input
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::*;
-
-    #[test]
-    fn part1() {
-        let challenge = day21::Day21 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part1(
-                utils::get_input(challenge.get_day(), utils::InputType::Test1)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-
-    #[test]
-    fn part2() {
-        let challenge = day21::Day21 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part2(
-                utils::get_input(challenge.get_day(), utils::InputType::Test2)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-}

src/solutions/day22.rs

@@ -1,66 +0,0 @@
-use super::Solution;
-
-pub struct Day22 {}
-
-impl Solution for Day22 {
-    fn part1(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn part2(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn get_day(&self) -> u8 {
-        22
-    }
-}
-
-impl Day22 {}
-
-/// Test from puzzle input
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::*;
-
-    #[test]
-    fn part1() {
-        let challenge = day22::Day22 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part1(
-                utils::get_input(challenge.get_day(), utils::InputType::Test1)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-
-    #[test]
-    fn part2() {
-        let challenge = day22::Day22 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part2(
-                utils::get_input(challenge.get_day(), utils::InputType::Test2)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-}

src/solutions/day23.rs

@@ -1,66 +0,0 @@
-use super::Solution;
-
-pub struct Day23 {}
-
-impl Solution for Day23 {
-    fn part1(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn part2(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn get_day(&self) -> u8 {
-        23
-    }
-}
-
-impl Day23 {}
-
-/// Test from puzzle input
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::*;
-
-    #[test]
-    fn part1() {
-        let challenge = day23::Day23 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part1(
-                utils::get_input(challenge.get_day(), utils::InputType::Test1)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-
-    #[test]
-    fn part2() {
-        let challenge = day23::Day23 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part2(
-                utils::get_input(challenge.get_day(), utils::InputType::Test2)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-}

src/solutions/day24.rs

@@ -1,66 +0,0 @@
-use super::Solution;
-
-pub struct Day24 {}
-
-impl Solution for Day24 {
-    fn part1(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn part2(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn get_day(&self) -> u8 {
-        24
-    }
-}
-
-impl Day24 {}
-
-/// Test from puzzle input
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::*;
-
-    #[test]
-    fn part1() {
-        let challenge = day24::Day24 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part1(
-                utils::get_input(challenge.get_day(), utils::InputType::Test1)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-
-    #[test]
-    fn part2() {
-        let challenge = day24::Day24 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part2(
-                utils::get_input(challenge.get_day(), utils::InputType::Test2)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-}

src/solutions/day25.rs

@@ -1,66 +0,0 @@
-use super::Solution;
-
-pub struct Day25 {}
-
-impl Solution for Day25 {
-    fn part1(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn part2(
-        &self,
-        _input: &mut Vec<String>,
-    ) -> Result<Box<dyn std::fmt::Display>, Box<dyn std::error::Error>> {
-        Ok(Box::new("Ready"))
-    }
-
-    fn get_day(&self) -> u8 {
-        25
-    }
-}
-
-impl Day25 {}
-
-/// Test from puzzle input
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::*;
-
-    #[test]
-    fn part1() {
-        let challenge = day25::Day25 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part1(
-                utils::get_input(challenge.get_day(), utils::InputType::Test1)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-
-    #[test]
-    fn part2() {
-        let challenge = day25::Day25 {};
-
-        //Complete the Challenge
-        let answer = challenge
-            .part2(
-                utils::get_input(challenge.get_day(), utils::InputType::Test2)
-                    .unwrap()
-                    .as_mut(),
-            )
-            .unwrap()
-            .to_string();
-
-        assert_eq!(answer, "Ready");
-    }
-}

src/solutions/mod.rs

@@ -10,19 +10,6 @@ pub mod day09;
 pub mod day10;
 pub mod day11;
 pub mod day12;
-pub mod day13;
-pub mod day14;
-pub mod day15;
-pub mod day16;
-pub mod day17;
-pub mod day18;
-pub mod day19;
-pub mod day20;
-pub mod day21;
-pub mod day22;
-pub mod day23;
-pub mod day24;
-pub mod day25;
 
 use crate::utils::{self, get_input};
 use std::{error::Error, fmt::Display, time::SystemTime};

src/utils.rs

@@ -1,7 +1,7 @@
 use std::{
     error::Error,
     fs::File,
-    io::{prelude::*, BufReader},
+    io::{BufReader, prelude::*},
 };
 
 /// Enum used to specify input