refactor: apply aoc-rust-common to 2015 days 3-5

Author: markkovari

2015/src/day03.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
-
-use crate::{Exercise, Solvable};
+use aoc_rust_common::Solution;
+use std::fmt::Display;
 
 type Position = (i32, i32);
 
@@ -48,87 +48,62 @@ impl Santa {
     }
 }
 
-struct ThirdDay {
-    exercise: Exercise,
-}
+pub struct Day03;
 
 fn get_visited_multiple_times(first: Santa, second: Santa) -> usize {
     let mut visited = HashMap::new();
     for (key, value) in first.visited.iter() {
-        visited.insert(key, value);
+        visited.insert(*key, *value);
     }
     for (key, value) in second.visited.iter() {
-        visited.insert(key, value);
+        visited.insert(*key, *value);
     }
     visited.values().filter(|&x| *x >= &1).count()
 }
 
-impl Solvable for ThirdDay {
-    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 Day03 {
+    fn year(&self) -> u32 { 2015 }
+    fn day(&self) -> u32 { 3 }
 
-    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 {
+    fn part1(&self, input: &str) -> Box<dyn Display> {
         let mut santa = Santa::new();
-        for direction in content.chars() {
+        for direction in input.chars() {
             santa.move_to(direction);
         }
-        santa.get_visited_multiple() as i64
+        Box::new(santa.get_visited_multiple() as i64)
     }
 
-    fn second(&self, content: &str) -> i64 {
+    fn part2(&self, input: &str) -> Box<dyn Display> {
         let mut santa = Santa::new();
         let mut robo_santa = Santa::new();
-        for direction in content.chars().enumerate() {
+        for direction in input.chars().enumerate() {
             if direction.0 % 2 == 0 {
                 santa.move_to(direction.1);
             } else {
                 robo_santa.move_to(direction.1);
             }
         }
-        get_visited_multiple_times(santa, robo_santa) as i64
+        Box::new(get_visited_multiple_times(santa, robo_santa) as i64)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    const EXAMPLE: &str = include_str!("inputs/3_test.txt");
-    const PROD: &str = include_str!("inputs/3_prod.txt");
 
     #[test]
-    fn first_test() {
-        let first_exercise = ThirdDay {
-            exercise: Exercise {
-                content: String::from(PROD),
-                example: String::from(EXAMPLE),
-            },
-        };
-
-        let expected_example = 4;
-        let expected_prod = 2572;
-
-        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);
+    fn test_day03() {
+        let day = Day03;
+        const PROD: &str = include_str!("inputs/3_prod.txt");
+        
+        assert_eq!(day.part1(">").to_string(), "2");
+        assert_eq!(day.part1("^>v<").to_string(), "4");
+        assert_eq!(day.part1("^v^v^v^v^v").to_string(), "2");
+        assert_eq!(day.part1(PROD).to_string(), "2572");
 
-        let expected_example = 3;
-        let expected_prod = 2631;
-        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);
+        assert_eq!(day.part2("^v").to_string(), "3");
+        assert_eq!(day.part2("^>v<").to_string(), "3");
+        assert_eq!(day.part2("^v^v^v^v^v").to_string(), "11");
+        assert_eq!(day.part2(PROD).to_string(), "2631");
     }
 }

2015/src/day04.rs

@@ -1,47 +1,36 @@
-use crate::{Exercise, Solvable};
+use aoc_rust_common::Solution;
+use std::fmt::Display;
 use md5;
 
-struct FourthDay {
-    exercise: Exercise,
-}
+pub struct Day04;
 
-impl Solvable for FourthDay {
-    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 Day04 {
+    fn year(&self) -> u32 { 2015 }
+    fn day(&self) -> u32 { 4 }
 
-    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 {
+    fn part1(&self, input: &str) -> Box<dyn Display> {
         let mut counter = 0;
+        let content = input.trim();
         loop {
             let data = format!("{}{}", content, counter);
             let calculated_hash = md5::compute(data);
             let hash_as_string = format!("{:x}", calculated_hash);
             if hash_as_string.starts_with("00000") {
-                return counter;
+                return Box::new(counter as i64);
             }
             counter += 1;
         }
     }
 
-    fn second(&self, content: &str) -> i64 {
+    fn part2(&self, input: &str) -> Box<dyn Display> {
         let mut counter = 0;
+        let content = input.trim();
         loop {
             let data = format!("{}{}", content, counter);
             let calculated_hash = md5::compute(data);
             let hash_as_string = format!("{:x}", calculated_hash);
             if hash_as_string.starts_with("000000") {
-                return counter;
+                return Box::new(counter as i64);
             }
             counter += 1;
         }
@@ -51,32 +40,12 @@ impl Solvable for FourthDay {
 #[cfg(test)]
 mod tests {
     use super::*;
-    const EXAMPLE: &str = include_str!("inputs/4_test.txt");
-    const PROD: &str = include_str!("inputs/4_prod.txt");
 
     #[test]
     #[ignore = "Takes too long"]
-    fn first_test() {
-        let first_exercise = FourthDay {
-            exercise: Exercise {
-                content: String::from(PROD),
-                example: String::from(EXAMPLE),
-            },
-        };
-
-        let expected_example = 1048970;
-        let expected_prod = 346386;
-
-        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 = 5714438;
-        let expected_prod = 9958218;
-        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_day04() {
+        let day = Day04;
+        assert_eq!(day.part1("abcdef").to_string(), "609043");
+        assert_eq!(day.part1("pqrstuv").to_string(), "1048970");
     }
 }

2015/src/day05.rs

@@ -1,99 +1,62 @@
-use crate::{Exercise, Solvable};
-use iter_tools::Itertools;
+use aoc_rust_common::Solution;
+use std::fmt::Display;
 use rayon::prelude::*;
 
-struct FifthDay {
-    exercise: Exercise,
-    vowels: Vec<char>,
-    filters: Vec<String>,
-}
-
-impl Solvable for FifthDay {
-    fn solve_first(&self, is_prod: bool) -> i64 {
-        if is_prod {
-            self.first(&self.exercise.content)
-        } else {
-            self.first(&self.exercise.example)
-        }
-    }
+pub struct Day05;
 
-    fn solve_second(&self, is_prod: bool) -> i64 {
-        if is_prod {
-            self.second(&self.exercise.content)
-        } else {
-            self.second(&self.exercise.example)
-        }
-    }
+impl Solution for Day05 {
+    fn year(&self) -> u32 { 2015 }
+    fn day(&self) -> u32 { 5 }
 
-    fn first(&self, content: &str) -> i64 {
-        content
+    fn part1(&self, input: &str) -> Box<dyn Display> {
+        let vowels = ['a', 'e', 'i', 'o', 'u'];
+        let filters = ["ab", "cd", "pq", "xy"];
+        
+        Box::new(input
             .par_lines()
-            .filter(|line: &&str| line.chars().filter(|c| self.vowels.contains(c)).count() >= 3)
-            .filter(|line: &&str| {
-                line.chars()
-                    .enumerate()
-                    .any(|(i, c)| i > 0 && c == line.chars().nth(i - 1).unwrap())
+            .filter(|line| line.chars().filter(|c| vowels.contains(c)).count() >= 3)
+            .filter(|line| {
+                let chars: Vec<char> = line.chars().collect();
+                chars.windows(2).any(|w| w[0] == w[1])
             })
-            .filter(|line: &&str| !self.filters.iter().any(|filter| line.contains(filter)))
-            .count() as i64
+            .filter(|line| !filters.iter().any(|&f| line.contains(f)))
+            .count() as i64)
     }
 
-    fn second(&self, content: &str) -> i64 {
-        content
+    fn part2(&self, input: &str) -> Box<dyn Display> {
+        Box::new(input
             .par_lines()
-            .filter(|line| line.len() >= 3)
-            .filter(|line: &&str| {
-                line.chars()
-                    .enumerate()
-                    .any(|(i, c)| i > 2 && c == line.chars().nth(i - 2).unwrap())
+            .filter(|line| {
+                let chars: Vec<char> = line.chars().collect();
+                chars.windows(3).any(|w| w[0] == w[2])
             })
-            .filter(|line: &&str| {
-                line.chars()
-                    .tuple_windows()
-                    .any(|(c1, c2)| line.matches(&format!("{}{}", c1, c2)).count() > 1)
+            .filter(|line| {
+                let chars: Vec<char> = line.chars().collect();
+                (0..chars.len() - 1).any(|i| {
+                    let pair = &line[i..i+2];
+                    line[i+2..].contains(pair)
+                })
             })
-            .count() as i64
+            .count() as i64)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    const EXAMPLE: &str = include_str!("inputs/5_test.txt");
-    const PROD: &str = include_str!("inputs/5_prod.txt");
 
     #[test]
-    fn first_test() {
-        let mut first_exercise = FifthDay {
-            exercise: Exercise {
-                content: String::from(PROD),
-                example: String::from(EXAMPLE),
-            },
-            vowels: vec!['a', 'e', 'i', 'o', 'u'],
-            filters: vec![
-                String::from("ab"),
-                String::from("cd"),
-                String::from("pq"),
-                String::from("xy"),
-            ],
-        };
-
-        let expected_example = 2;
-        let expected_prod = 255;
-
-        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);
-
-        first_exercise.exercise.example =
-            String::from("qjhvhtzxzqqjkmpb\nxxyxx\nuurcxstgmygtbstg\nieodomkazucvgmuy");
-
-        let expected_example = 2;
-        let expected_prod = 55;
-        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_day05() {
+        let day = Day05;
+        assert_eq!(day.part1("ugknbfddgicrmopn").to_string(), "1");
+        assert_eq!(day.part1("aaa").to_string(), "1");
+        assert_eq!(day.part1("jchzalrnumimnmhp").to_string(), "0");
+        assert_eq!(day.part1("haegwjzuvuyypxyu").to_string(), "0");
+        assert_eq!(day.part1("dvszwmarrgswjxmb").to_string(), "0");
+
+        assert_eq!(day.part2("qjhvhtzxzqqjkmpb").to_string(), "1");
+        assert_eq!(day.part2("xxyxx").to_string(), "1");
+        assert_eq!(day.part2("uurcxstgmygtbstg").to_string(), "0");
+        assert_eq!(day.part2("ieodomkazucvgmuy").to_string(), "0");
     }
 }

2015/src/main.rs

@@ -1,11 +1,20 @@
 mod day01;
 mod day02;
+mod day03;
+mod day04;
+mod day05;
 
 use aoc_rust_common::run_solution;
 use day01::Day01;
 use day02::Day02;
+use day03::Day03;
+use day04::Day04;
+use day05::Day05;
 
 fn main() {
     run_solution(Day01);
     run_solution(Day02);
+    run_solution(Day03);
+    run_solution(Day04);
+    run_solution(Day05);
 }