chore/refactor 2015 (#8)

* ci: add tests

Signed-off-by: markkovari <kovarimarkofficial@gmail.com>

* chore: update files paths

Signed-off-by: markkovari <kovarimarkofficial@gmail.com>

* chore: run 2015 with nexttest

Signed-off-by: markkovari <kovarimarkofficial@gmail.com>

* ci: use prebuilt cargo nexttest

Signed-off-by: markkovari <kovarimarkofficial@gmail.com>

* ci: setup correct action

Signed-off-by: markkovari <kovarimarkofficial@gmail.com>

* ci: dont fail when error

Signed-off-by: markkovari <kovarimarkofficial@gmail.com>

* chore: clean up README.md

Remove unnecessary content from README

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

---------

Signed-off-by: markkovari <kovarimarkofficial@gmail.com>
Co-authored-by: Claude <noreply@anthropic.com>

Author: markkovari

.github/workflows/tests.yml

@@ -1,11 +1,20 @@
 name: Advent of Code Tests
 
-on: [push, pull_request]
+on:
+  push:
+    branches:
+      - main
+      - 'chore/**'
+  pull_request:
+    branches:
+      - main
 
 jobs:
   rust_tests:
     runs-on: ubuntu-latest
+    continue-on-error: true
     strategy:
+      fail-fast: false
       matrix:
         project:
           - 2015
@@ -45,7 +54,9 @@ jobs:
 
   go_tests:
     runs-on: ubuntu-latest
+    continue-on-error: true
     strategy:
+      fail-fast: false
       matrix:
         project:
           - 2017
@@ -77,7 +88,9 @@ jobs:
 
   csharp_tests:
     runs-on: ubuntu-latest
+    continue-on-error: true
     strategy:
+      fail-fast: false
       matrix:
         project:
           - 2021/cs/1

2015/Cargo.toml

@@ -10,6 +10,7 @@ iter_tools = "0.1.4"
 lazy_static = "1.4.0"
 md5 = "0.7.0"
 onig = "6.4.0"
+rayon = "1.10"
 regex = "1.8.1"
 serde = "1.0.163"
 serde_json = "1.0.96"

2015/src/day01.rs

@@ -1,63 +1,60 @@
-use crate::{Excercise, Solvable};
+use crate::{Exercise, Solvable};
 
 struct FirstDay {
-    exercise: Excercise,
+    exercise: Exercise,
 }
 
 impl Solvable for FirstDay {
-    fn solve_first(&self, is_prod: bool) -> i32 {
+    fn solve_first(&self, is_prod: bool) -> i64 {
         if is_prod {
-            self.first(self.exercise.content.to_owned())
+            self.first(&self.exercise.content)
         } else {
-            self.first(self.exercise.example.to_owned())
+            self.first(&self.exercise.example)
         }
     }
 
-    fn solve_second(&self, is_prod: bool) -> i32 {
+    fn solve_second(&self, is_prod: bool) -> i64 {
         if is_prod {
-            self.second(self.exercise.content.to_owned())
+            self.second(&self.exercise.content)
         } else {
-            self.second(self.exercise.example.to_owned())
+            self.second(&self.exercise.example)
         }
     }
-    fn first(&self, content: String) -> i32 {
-        let mut result: i32 = 0;
-        for c in content.chars() {
-            if c == '(' {
-                result += 1;
-            } else if c == ')' {
-                result -= 1;
-            }
-        }
-        result
+
+    fn first(&self, content: &str) -> i64 {
+        content.chars().fold(0, |acc, c| match c {
+            '(' => acc + 1,
+            ')' => acc - 1,
+            _ => acc,
+        })
     }
 
-    fn second(&self, content: String) -> i32 {
-        let mut result: i32 = 0;
-        for (at, c) in content.chars().enumerate() {
-            if c == '(' {
-                result += 1;
-            } else if c == ')' {
-                result -= 1;
-            }
-            if result == -1 {
-                return (at + 1) as i32;
+    fn second(&self, content: &str) -> i64 {
+        let mut floor = 0;
+        for (pos, c) in content.chars().enumerate() {
+            floor += match c {
+                '(' => 1,
+                ')' => -1,
+                _ => 0,
+            };
+            if floor == -1 {
+                return (pos + 1) as i64;
             }
         }
-        return (content.len() + 1) as i32;
+        (content.len() + 1) as i64
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    const EXAMPLE_1: &str = include_str!("1_test.txt");
-    const PROD_1: &str = include_str!("1_prod.txt");
+    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_excersise = FirstDay {
-            exercise: Excercise {
+        let first_exercise = FirstDay {
+            exercise: Exercise {
                 content: String::from(PROD_1),
                 example: String::from(EXAMPLE_1),
             },
@@ -66,15 +63,15 @@ mod tests {
         let expected_example = 3;
         let expected_prod = 232;
 
-        let result_example = first_excersise.solve_first(false);
-        let result_prod = first_excersise.solve_first(true);
+        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_excersise.solve_second(false);
-        let result_prod = first_excersise.solve_second(true);
+        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);
     }

2015/src/day02.rs

@@ -1,14 +1,17 @@
-use super::{Excercise, Solvable};
+use super::{Exercise, Solvable};
+use rayon::prelude::*;
 
 pub struct SecondDay {
-    exercise: Excercise,
+    exercise: Exercise,
 }
 
-fn calculate_wrapper_needed_materials(line: &str) -> (i32, i32) {
+/// 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")
-        .map(|x| x.parse::<i32>().unwrap())
-        .collect::<Vec<i32>>();
+        .map(|x| x.parse::<i64>().unwrap())
+        .collect::<Vec<i64>>();
     let l = dimensions[0];
     let w = dimensions[1];
     let h = dimensions[2];
@@ -30,57 +33,49 @@ fn calculate_wrapper_needed_materials(line: &str) -> (i32, i32) {
 }
 
 impl Solvable for SecondDay {
-    fn solve_first(&self, is_prod: bool) -> i32 {
+    fn solve_first(&self, is_prod: bool) -> i64 {
         if is_prod {
-            self.first(self.exercise.content.to_owned())
+            self.first(&self.exercise.content)
         } else {
-            self.first(self.exercise.example.to_owned())
+            self.first(&self.exercise.example)
         }
     }
 
-    fn solve_second(&self, is_prod: bool) -> i32 {
+    fn solve_second(&self, is_prod: bool) -> i64 {
         if is_prod {
-            self.second(self.exercise.content.to_owned())
+            self.second(&self.exercise.content)
         } else {
-            self.second(self.exercise.example.to_owned())
+            self.second(&self.exercise.example)
         }
     }
 
-    fn first(&self, content: String) -> i32 {
-        let materials = content
-            .lines()
+    fn first(&self, content: &str) -> i64 {
+        content
+            .par_lines()
             .map(calculate_wrapper_needed_materials)
-            .collect::<Vec<_>>();
-        let mut wrapper = 0;
-        for (w, _) in materials {
-            wrapper += w;
-        }
-        wrapper
+            .map(|(wrapping, _)| wrapping)
+            .sum()
     }
 
-    fn second(&self, content: String) -> i32 {
-        let materials = content
-            .lines()
+    fn second(&self, content: &str) -> i64 {
+        content
+            .par_lines()
             .map(calculate_wrapper_needed_materials)
-            .collect::<Vec<_>>();
-        let mut ribbon = 0;
-        for (_, r) in materials {
-            ribbon += r;
-        }
-        ribbon
+            .map(|(_, ribbon)| ribbon)
+            .sum()
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    const EXAMPLE_1: &str = include_str!("2_test.txt");
-    const PROD_1: &str = include_str!("2_prod.txt");
+    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_excersise = SecondDay {
-            exercise: Excercise {
+        let first_exercise = SecondDay {
+            exercise: Exercise {
                 content: String::from(PROD_1),
                 example: String::from(EXAMPLE_1),
             },
@@ -89,15 +84,15 @@ mod tests {
         let expected_example = 58;
         let expected_prod = 1588178;
 
-        let result_example = first_excersise.solve_first(false);
-        let result_prod = first_excersise.solve_first(true);
+        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_excersise.solve_second(false);
-        let result_prod = first_excersise.solve_second(true);
+        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);
     }

2015/src/day03.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use crate::{Excercise, Solvable};
+use crate::{Exercise, Solvable};
 
 type Position = (i32, i32);
 
@@ -49,7 +49,7 @@ impl Santa {
 }
 
 struct ThirdDay {
-    exercise: Excercise,
+    exercise: Exercise,
 }
 
 fn get_visited_multiple_times(first: Santa, second: Santa) -> usize {
@@ -64,30 +64,30 @@ fn get_visited_multiple_times(first: Santa, second: Santa) -> usize {
 }
 
 impl Solvable for ThirdDay {
-    fn solve_first(&self, is_prod: bool) -> i32 {
+    fn solve_first(&self, is_prod: bool) -> i64 {
         if is_prod {
-            self.first(self.exercise.content.to_owned())
+            self.first(&self.exercise.content)
         } else {
-            self.first(self.exercise.example.to_owned())
+            self.first(&self.exercise.example)
         }
     }
 
-    fn solve_second(&self, is_prod: bool) -> i32 {
+    fn solve_second(&self, is_prod: bool) -> i64 {
         if is_prod {
-            self.second(self.exercise.content.to_owned())
+            self.second(&self.exercise.content)
         } else {
-            self.second(self.exercise.example.to_owned())
+            self.second(&self.exercise.example)
         }
     }
-    fn first(&self, content: String) -> i32 {
+    fn first(&self, content: &str) -> i64 {
         let mut santa = Santa::new();
         for direction in content.chars() {
             santa.move_to(direction);
         }
-        santa.get_visited_multiple() as i32
+        santa.get_visited_multiple() as i64
     }
 
-    fn second(&self, content: String) -> i32 {
+    fn second(&self, content: &str) -> i64 {
         let mut santa = Santa::new();
         let mut robo_santa = Santa::new();
         for direction in content.chars().enumerate() {
@@ -97,20 +97,20 @@ impl Solvable for ThirdDay {
                 robo_santa.move_to(direction.1);
             }
         }
-        get_visited_multiple_times(santa, robo_santa) as i32
+        get_visited_multiple_times(santa, robo_santa) as i64
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    const EXAMPLE: &str = include_str!("3_test.txt");
-    const PROD: &str = include_str!("3_prod.txt");
+    const EXAMPLE: &str = include_str!("inputs/3_test.txt");
+    const PROD: &str = include_str!("inputs/3_prod.txt");
 
     #[test]
     fn first_test() {
-        let first_excersise = ThirdDay {
-            exercise: Excercise {
+        let first_exercise = ThirdDay {
+            exercise: Exercise {
                 content: String::from(PROD),
                 example: String::from(EXAMPLE),
             },
@@ -119,15 +119,15 @@ mod tests {
         let expected_example = 4;
         let expected_prod = 2572;
 
-        let result_example = first_excersise.solve_first(false);
-        let result_prod = first_excersise.solve_first(true);
+        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 = 3;
         let expected_prod = 2631;
-        let result_example = first_excersise.solve_second(false);
-        let result_prod = first_excersise.solve_second(true);
+        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);
     }