feat: introduce shared aoc-rust-common framework and workspace

This commit sets up a root Cargo workspace and a shared framework for Rust solutions, including standardized Solution traits, input loading, and execution timing. Refactored 2015 Day 1 and 2 as a proof of concept.

Author: markkovari

2015/Cargo.toml

@@ -6,6 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+aoc-rust-common = { path = "../aoc-rust-common" }
 iter_tools = "0.1.4"
 lazy_static = "1.4.0"
 md5 = "0.7.0"

2015/src/day01.rs

@@ -1,78 +1,54 @@
-use crate::{Exercise, Solvable};
+use aoc_rust_common::Solution;
+use std::fmt::Display;
 
-struct FirstDay {
-    exercise: Exercise,
-}
+pub struct Day01;
 
-impl Solvable for FirstDay {
-    fn solve_first(&self, is_prod: bool) -> i64 {
-        if is_prod {
-            self.first(&self.exercise.content)
-        } else {
-            self.first(&self.exercise.example)
-        }
-    }
+impl Solution for Day01 {
+    fn year(&self) -> u32 { 2015 }
+    fn day(&self) -> u32 { 1 }
 
-    fn solve_second(&self, is_prod: bool) -> i64 {
-        if is_prod {
-            self.second(&self.exercise.content)
-        } else {
-            self.second(&self.exercise.example)
-        }
-    }
-
-    fn first(&self, content: &str) -> i64 {
-        content.chars().fold(0, |acc, c| match c {
+    fn part1(&self, input: &str) -> Box<dyn Display> {
+        Box::new(input.chars().fold(0, |acc, c| match c {
             '(' => acc + 1,
             ')' => acc - 1,
             _ => acc,
-        })
+        }))
     }
 
-    fn second(&self, content: &str) -> i64 {
+    fn part2(&self, input: &str) -> Box<dyn Display> {
         let mut floor = 0;
-        for (pos, c) in content.chars().enumerate() {
+        for (pos, c) in input.chars().enumerate() {
             floor += match c {
                 '(' => 1,
                 ')' => -1,
                 _ => 0,
             };
             if floor == -1 {
-                return (pos + 1) as i64;
+                return Box::new((pos + 1) as i64);
             }
         }
-        (content.len() + 1) as i64
+        Box::new((input.len() + 1) as i64)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    const EXAMPLE_1: &str = include_str!("inputs/1_test.txt");
-    const PROD_1: &str = include_str!("inputs/1_prod.txt");
 
     #[test]
-    fn first_test() {
-        let first_exercise = FirstDay {
-            exercise: Exercise {
-                content: String::from(PROD_1),
-                example: String::from(EXAMPLE_1),
-            },
-        };
-
-        let expected_example = 3;
-        let expected_prod = 232;
-
-        let result_example = first_exercise.solve_first(false);
-        let result_prod = first_exercise.solve_first(true);
-        assert_eq!(expected_example, result_example);
-        assert_eq!(expected_prod, result_prod);
-
-        let expected_example = 1;
-        let expected_prod = 1783;
-        let result_example = first_exercise.solve_second(false);
-        let result_prod = first_exercise.solve_second(true);
-        assert_eq!(expected_example, result_example);
-        assert_eq!(expected_prod, result_prod);
+    fn test_day01() {
+        let day = Day01;
+        assert_eq!(day.part1("(())").to_string(), "0");
+        assert_eq!(day.part1("()()").to_string(), "0");
+        assert_eq!(day.part1("(((").to_string(), "3");
+        assert_eq!(day.part1("(()(()(").to_string(), "3");
+        assert_eq!(day.part1("))(((((").to_string(), "3");
+        assert_eq!(day.part1("())").to_string(), "-1");
+        assert_eq!(day.part1("))(").to_string(), "-1");
+        assert_eq!(day.part1(")))").to_string(), "-3");
+        assert_eq!(day.part1(")())())").to_string(), "-3");
+
+        assert_eq!(day.part2(")").to_string(), "1");
+        assert_eq!(day.part2("()())").to_string(), "5");
     }
 }

2015/src/day02.rs

@@ -1,99 +1,62 @@
-use super::{Exercise, Solvable};
+use aoc_rust_common::Solution;
+use std::fmt::Display;
 use rayon::prelude::*;
 
-pub struct SecondDay {
-    exercise: Exercise,
-}
+pub struct Day02;
 
-/// Calculate wrapping paper and ribbon needed for a present
-/// Returns (wrapping_paper_area, ribbon_length)
 fn calculate_wrapper_needed_materials(line: &str) -> (i64, i64) {
     let dimensions = line
-        .split("x")
+        .split('x')
         .map(|x| x.parse::<i64>().unwrap())
         .collect::<Vec<i64>>();
     let l = dimensions[0];
     let w = dimensions[1];
     let h = dimensions[2];
-    let mut smallest = l * w;
-    let mut smallest_perimeter = l + w;
+    
+    let areas = [l * w, w * h, h * l];
+    let smallest = areas.iter().min().unwrap();
+    
+    let perimeters = [2 * (l + w), 2 * (w + h), 2 * (h + l)];
+    let smallest_perimeter = perimeters.iter().min().unwrap();
 
-    if w * h < smallest {
-        smallest = w * h;
-        smallest_perimeter = w + h;
-    }
-    if h * l < smallest {
-        smallest = h * l;
-        smallest_perimeter = h + l;
-    }
     (
         2 * l * w + 2 * w * h + 2 * h * l + smallest,
-        smallest_perimeter * 2 + l * w * h,
+        smallest_perimeter + l * w * h,
     )
 }
 
-impl Solvable for SecondDay {
-    fn solve_first(&self, is_prod: bool) -> i64 {
-        if is_prod {
-            self.first(&self.exercise.content)
-        } else {
-            self.first(&self.exercise.example)
-        }
-    }
+impl Solution for Day02 {
+    fn year(&self) -> u32 { 2015 }
+    fn day(&self) -> u32 { 2 }
 
-    fn solve_second(&self, is_prod: bool) -> i64 {
-        if is_prod {
-            self.second(&self.exercise.content)
-        } else {
-            self.second(&self.exercise.example)
-        }
-    }
-
-    fn first(&self, content: &str) -> i64 {
-        content
+    fn part1(&self, input: &str) -> Box<dyn Display> {
+        Box::new(input
             .par_lines()
             .map(calculate_wrapper_needed_materials)
             .map(|(wrapping, _)| wrapping)
-            .sum()
+            .sum::<i64>())
     }
 
-    fn second(&self, content: &str) -> i64 {
-        content
+    fn part2(&self, input: &str) -> Box<dyn Display> {
+        Box::new(input
             .par_lines()
             .map(calculate_wrapper_needed_materials)
             .map(|(_, ribbon)| ribbon)
-            .sum()
+            .sum::<i64>())
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    const EXAMPLE_1: &str = include_str!("inputs/2_test.txt");
-    const PROD_1: &str = include_str!("inputs/2_prod.txt");
 
     #[test]
-    fn first_test() {
-        let first_exercise = SecondDay {
-            exercise: Exercise {
-                content: String::from(PROD_1),
-                example: String::from(EXAMPLE_1),
-            },
-        };
-
-        let expected_example = 58;
-        let expected_prod = 1588178;
-
-        let result_example = first_exercise.solve_first(false);
-        let result_prod = first_exercise.solve_first(true);
-        assert_eq!(expected_example, result_example);
-        assert_eq!(expected_prod, result_prod);
-
-        let expected_example = 34;
-        let expected_prod = 3783758;
-        let result_example = first_exercise.solve_second(false);
-        let result_prod = first_exercise.solve_second(true);
-        assert_eq!(expected_example, result_example);
-        assert_eq!(expected_prod, result_prod);
+    fn test_day02() {
+        let day = Day02;
+        assert_eq!(day.part1("2x3x4").to_string(), "58");
+        assert_eq!(day.part1("1x1x10").to_string(), "43");
+        
+        assert_eq!(day.part2("2x3x4").to_string(), "34");
+        assert_eq!(day.part2("1x1x10").to_string(), "14");
     }
 }

2015/src/main.rs

@@ -0,0 +1,11 @@
+mod day01;
+mod day02;
+
+use aoc_rust_common::run_solution;
+use day01::Day01;
+use day02::Day02;
+
+fn main() {
+    run_solution(Day01);
+    run_solution(Day02);
+}