refactor: apply aoc-rust-common to 2015 days 11-15

Author: markkovari

2015/src/day11.rs

@@ -1,8 +1,7 @@
-use crate::Exercise;
+use aoc_rust_common::Solution;
+use std::fmt::Display;
 
-struct EleventhDay {
-    exercise: Exercise,
-}
+pub struct Day11;
 
 fn increment(character: char) -> char {
     match character {
@@ -11,15 +10,16 @@ fn increment(character: char) -> char {
     }
 }
 
-fn has_two_non_overlapping_pairs(password: &mut str) -> bool {
+fn has_two_non_overlapping_pairs(password: &str) -> bool {
     let mut pairs = 0;
     let mut index = 0;
+    let chars: Vec<char> = password.chars().collect();
     loop {
-        if index >= password.len() - 1 {
+        if index >= chars.len() - 1 {
             break;
         }
-        let character = password.chars().nth(index).unwrap();
-        let next_character = password.chars().nth(index + 1).unwrap();
+        let character = chars[index];
+        let next_character = chars[index + 1];
         if character == next_character {
             pairs += 1;
             index += 2;
@@ -30,16 +30,11 @@ fn has_two_non_overlapping_pairs(password: &mut str) -> bool {
     pairs >= 2
 }
 
-fn is_valid_password(password: &mut str) -> bool {
+fn is_valid_password(password: &str) -> bool {
+    let chars: Vec<char> = password.chars().collect();
     let mut triples = 0;
-    for window in password.chars().collect::<Vec<char>>().windows(3) {
-        if window[0] == 'i' || window[0] == 'o' || window[0] == 'l' {
-            return false;
-        }
-        if window[1] == 'i' || window[1] == 'o' || window[1] == 'l' {
-            return false;
-        }
-        if window[2] == 'i' || window[2] == 'o' || window[2] == 'l' {
+    for window in chars.windows(3) {
+        if window.iter().any(|&c| c == 'i' || c == 'o' || c == 'l') {
             return false;
         }
         if window[0] as u8 + 1 == window[1] as u8 && window[1] as u8 + 1 == window[2] as u8 {
@@ -57,87 +52,53 @@ fn create_new_password(password: String) -> String {
     let mut password = password;
     loop {
         password = increment_password(password);
-        if is_valid_password(&mut password) {
+        if is_valid_password(&password) {
             break;
         }
     }
     password
 }
 
 fn increment_password(password: String) -> String {
-    let mut password = password;
-    let mut index = password.len() - 1;
+    let mut chars: Vec<char> = password.chars().collect();
+    let mut index = chars.len() - 1;
     loop {
-        let character = password.chars().nth(index).unwrap();
+        let character = chars[index];
         let new_character = increment(character);
-        password.replace_range(index..=index, &new_character.to_string());
+        chars[index] = new_character;
         if new_character == 'a' {
+            if index == 0 { break; }
             index -= 1;
         } else {
             break;
         }
     }
-    password
+    chars.iter().collect()
 }
 
-impl EleventhDay {
-    fn solve_first(&self, is_prod: bool) -> String {
-        if is_prod {
-            self.first(self.exercise.content.clone())
-        } else {
-            self.first(self.exercise.example.clone())
-        }
-    }
-
-    fn solve_second(&self, is_prod: bool) -> String {
-        if is_prod {
-            self.second(self.exercise.content.clone())
-        } else {
-            self.second(self.exercise.example.clone())
-        }
-    }
+impl Solution for Day11 {
+    fn year(&self) -> u32 { 2015 }
+    fn day(&self) -> u32 { 11 }
 
-    fn first(&self, content: String) -> String {
-        create_new_password(content)
+    fn part1(&self, input: &str) -> Box<dyn Display> {
+        Box::new(create_new_password(input.trim().to_owned()))
     }
 
-    fn second(&self, _content: String) -> String {
-        "asd".to_owned()
+    fn part2(&self, input: &str) -> Box<dyn Display> {
+        let p1 = create_new_password(input.trim().to_owned());
+        Box::new(create_new_password(p1))
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    const EXAMPLE: &str = include_str!("inputs/11_test.txt");
-    const PROD: &str = include_str!("inputs/11_prod.txt");
-
-    #[test]
-    fn test_valid_password() {
-        let is_valid = is_valid_password(&mut "abcdffaa".to_owned());
-        assert_eq!(is_valid, true);
-    }
 
     #[test]
-    #[ignore = "Takes too long"]
-    fn first_test() {
-        let mut first_exercise = EleventhDay {
-            exercise: Exercise {
-                content: String::from(PROD),
-                example: String::from(EXAMPLE),
-            },
-        };
-
-        let expected_example = "abcdffaa";
-        let expected_prod = "hxbxxyzz";
-
-        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_prod = "hxcaabcc";
-        let result_prod = create_new_password(result_prod);
-        assert_eq!(expected_prod, result_prod);
+    fn test_day11() {
+        assert!(is_valid_password("abcdffaa"));
+        assert!(!is_valid_password("hijklmmn"));
+        assert!(!is_valid_password("abbceffg"));
+        assert!(!is_valid_password("abbcegjk"));
     }
 }

2015/src/day12.rs

@@ -1,13 +1,12 @@
-use crate::Exercise;
+use aoc_rust_common::Solution;
+use std::fmt::Display;
 use serde_json::Value;
 
-struct TwelvfthDay {
-    exercise: Exercise,
-}
+pub struct Day12;
 
 fn count_value(value: &Value) -> i32 {
     match value {
-        Value::Number(e) => e.as_i64().unwrap() as i32,
+        Value::Number(e) => e.as_i64().unwrap_or(0) as i32,
         Value::Array(array) => array.iter().map(count_value).sum(),
         Value::Object(object) => object.values().map(count_value).sum(),
         _ => 0,
@@ -16,10 +15,10 @@ fn count_value(value: &Value) -> i32 {
 
 fn skip_red(value: &Value) -> i32 {
     match value {
-        Value::Number(e) => e.as_i64().unwrap() as i32,
+        Value::Number(e) => e.as_i64().unwrap_or(0) as i32,
         Value::Array(array) => array.iter().map(skip_red).sum(),
         Value::Object(object) => {
-            if object.values().any(|v| v == "red") {
+            if object.values().any(|v| v.as_str() == Some("red")) {
                 0
             } else {
                 object.values().map(skip_red).sum()
@@ -29,63 +28,31 @@ fn skip_red(value: &Value) -> i32 {
     }
 }
 
-impl TwelvfthDay {
-    fn solve_first(&self, is_prod: bool) -> i64 {
-        if is_prod {
-            self.first(&self.exercise.content)
-        } else {
-            self.first(&self.exercise.example)
-        }
-    }
-
-    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 Day12 {
+    fn year(&self) -> u32 { 2015 }
+    fn day(&self) -> u32 { 12 }
 
-    fn first(&self, content: &str) -> i64 {
-        let value: Value = serde_json::from_str(content).unwrap();
-        count_value(&value) as i64
+    fn part1(&self, input: &str) -> Box<dyn Display> {
+        let value: Value = serde_json::from_str(input).unwrap();
+        Box::new(count_value(&value) as i64)
     }
 
-    fn second(&self, content: &str) -> i64 {
-        let value: Value = serde_json::from_str(content).unwrap();
-        skip_red(&value) as i64
+    fn part2(&self, input: &str) -> Box<dyn Display> {
+        let value: Value = serde_json::from_str(input).unwrap();
+        Box::new(skip_red(&value) as i64)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    const EXAMPLE: &str = include_str!("inputs/12_test.txt");
-    const PROD: &str = include_str!("inputs/12_prod.txt");
 
     #[test]
-    fn first_test() {
-        let mut first_exercise = TwelvfthDay {
-            exercise: Exercise {
-                content: String::from(PROD),
-                example: String::from(EXAMPLE),
-            },
-        };
-
-        let expected_example = 3;
-        let expected_prod = 156366;
-
-        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 = 96852;
-
-        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_day12() {
+        let day = Day12;
+        assert_eq!(day.part1("[1,2,3]").to_string(), "6");
+        assert_eq!(day.part1(r#"{"a":2,"b":4}"#).to_string(), "6");
+        assert_eq!(day.part2("[1,2,3]").to_string(), "6");
+        assert_eq!(day.part2(r#"[1,{"c":"red","a":2},3]"#).to_string(), "4");
     }
 }