[rust] Don't use a Day trait

rust/src/day_01.rs

@@ -1,20 +1,8 @@
-use std::io;
 use std::str::Chars;
 
-use day::Day;
+pub fn solve(input: &str) -> i32 {
-
+    let elevator = Elevator::new(input.to_string());
-pub struct Day01 {
+    1 + elevator.run().position(|f| f == -1).unwrap_or(0) as i32
-    elevator: Elevator,
-}
-
-impl Day for Day01 {
-    fn new(input: String) -> Day01 {
-        Day01 { elevator: Elevator::new(input) }
-    }
-
-    fn solve(&self) -> io::Result<i32> {
-        Ok(1 + self.elevator.run().position(|f| f == -1).unwrap_or(0) as i32)
-    }
 }
 
 struct Elevator {

rust/src/day_02.rs

@@ -1,20 +1,6 @@
-use std::io;
+pub fn solve(input: &str) -> i32 {
-
+    let presents = input.split("\n").map(|line| Present::new(line)).collect::<Vec<Present>>();
-use day::Day;
+    presents.iter().fold(0u32, |acc, present| acc + present.ribbon()) as i32
-
-pub struct Day02 {
-    presents: Vec<Present>,
-}
-
-impl Day for Day02 {
-    fn new(input: String) -> Day02 {
-        let presents = input.split("\n").map(|line| Present::new(line));
-        Day02 { presents: presents.collect::<Vec<Present>>() }
-    }
-
-    fn solve(&self) -> io::Result<i32> {
-        Ok(self.presents.iter().fold(0u32, |acc, present| acc + present.ribbon()) as i32)
-    }
 }
 
 struct Present {

rust/src/day_03.rs

@@ -1,42 +1,29 @@
 use std::cmp::Eq;
 use std::collections::HashMap;
 use std::fmt;
-use std::io;
 use std::ops::Add;
 use std::str::Chars;
 
-use day::Day;
+pub fn solve(input: &str) -> i32 {
+    let mut santa = String::new();
+    let mut robo_santa = String::new();
+    let mut iter = input.chars();
 
-pub struct Day03 {
+    loop {
-    directions: String,
+        match iter.next() {
-}
+            Some(c) => { santa.push(c) },
-
+            None => break,
-impl Day for Day03 {
+        }
-    fn new(input: String) -> Day03 {
+        match iter.next() {
-        Day03 { directions: input }
+            Some(c) => { robo_santa.push(c) },
-    }
+            None => break,
-
-    fn solve(&self) -> io::Result<i32> {
-        let mut santa = String::new();
-        let mut robo_santa = String::new();
-        let mut iter = self.directions.chars();
-
-        loop {
-            match iter.next() {
-                Some(c) => { santa.push(c) },
-                None => break,
-            }
-            match iter.next() {
-                Some(c) => { robo_santa.push(c) },
-                None => break,
-            }
         }
-
-        let mut houses: HashMap<Point, u32> = HashMap::new();
-        Santa::houses_visited(&santa, &mut houses);
-        Santa::houses_visited(&robo_santa, &mut houses);
-        Ok(houses.len() as i32)
     }
+
+    let mut houses: HashMap<Point, u32> = HashMap::new();
+    Santa::houses_visited(&santa, &mut houses);
+    Santa::houses_visited(&robo_santa, &mut houses);
+    houses.len() as i32
 }
 
 struct Santa<'a> {

rust/src/day_04.rs

@@ -1,42 +1,27 @@
-use std::io;
-
 use crypto::md5::Md5;
 use crypto::digest::Digest;
 
-use day::Day;
+pub fn solve(input: &str) -> i32 {
-
+    let mut md5 = Md5::new();
-pub struct Day04 {
+    let key = input.as_bytes();
-    secret: String,
+    let mut i = 0;
-}
+    let mut out = [0; 16];
-
+    loop {
-impl Day for Day04 {
+        i += 1;
-    fn new(input: String) -> Day04 {
-        Day04 { secret: input }
-    }
-
-    fn solve(&self) -> io::Result<i32> {
-        let mut md5 = Md5::new();
-        let key = self.secret.as_bytes();
-        let mut i = 0;
-        let mut out = [0; 16];
-        loop {
-            i += 1;
 
-            md5.input(key);
+        md5.input(key);
-            md5.input(i.to_string().as_bytes());
+        md5.input(i.to_string().as_bytes());
-            md5.result(&mut out);
+        md5.result(&mut out);
-            if out[0] == 0 && out[1] == 0 && out[2] == 0 {
+        if out[0] == 0 && out[1] == 0 && out[2] == 0 {
-                break;
+            break;
-            }
-            md5.reset();
         }
-        Ok(i)
+        md5.reset();
     }
+    i
 }
 
 #[test]
 #[ignore]
 fn test_day04() {
-    let day = Day04::new("abcdef".to_string());
+    assert_eq!(609043, solve("abcdef"));
-    assert_eq!(609043, day.solve().unwrap());
 }

rust/src/day_05.rs

@@ -1,59 +1,44 @@
-use std::io;
+#![allow(dead_code)]
 
 use regex::Regex;
 
-use day::Day;
+pub fn solve(input: &str) -> i32 {
-
+    input.lines().filter(|&s| is_nice(&s.to_string())).count() as i32
-pub struct Day05 {
-    input: String,
 }
 
-#[allow(dead_code)]
+fn is_nice(string: &String) -> bool {
-impl Day05 {
+    has_pair_of_two_letters(string) &&
-    fn is_nice(string: &String) -> bool {
+        has_letter_sandwich(string)
-        Day05::has_pair_of_two_letters(string) &&
+}
-            Day05::has_letter_sandwich(string)
-    }
-
-    fn has_three_vowels(string: &String) -> bool {
-        let three_vowels = Regex::new(r"[aeiou].*[aeiou].*[aeiou]").unwrap();
-        three_vowels.is_match(string)
-    }
-
-    fn has_double_letters(string: &String) -> bool {
-        string.as_bytes().windows(2).any(|win| win[0] == win[1])
-    }
 
-    fn has_no_substrings(string: &String) -> bool {
+fn has_three_vowels(string: &String) -> bool {
-        !vec!["ab", "cd", "pq", "xy"].iter().any(|&s| string.contains(s))
+    let three_vowels = Regex::new(r"[aeiou].*[aeiou].*[aeiou]").unwrap();
-    }
+    three_vowels.is_match(string)
+}
 
-    fn has_pair_of_two_letters(string: &String) -> bool {
+fn has_double_letters(string: &String) -> bool {
-        string.as_bytes().windows(2).any(|win| {
+    string.as_bytes().windows(2).any(|win| win[0] == win[1])
-            let s = String::from_utf8(win.to_vec()).unwrap();
+}
-            string.split(&s).count() > 2
-        })
-    }
 
-    fn has_letter_sandwich(string: &String) -> bool {
+fn has_no_substrings(string: &String) -> bool {
-        string.as_bytes().windows(3).any(|win| win[0] == win[2])
+    !vec!["ab", "cd", "pq", "xy"].iter().any(|&s| string.contains(s))
-    }
 }
 
-impl Day for Day05 {
+fn has_pair_of_two_letters(string: &String) -> bool {
-    fn new(input: String) -> Day05 {
+    string.as_bytes().windows(2).any(|win| {
-        Day05 { input: input }
+        let s = String::from_utf8(win.to_vec()).unwrap();
-    }
+        string.split(&s).count() > 2
+    })
+}
 
-    fn solve(&self) -> io::Result<i32> {
+fn has_letter_sandwich(string: &String) -> bool {
-        Ok(self.input.lines().filter(|&s| Day05::is_nice(&s.to_string())).count() as i32)
+    string.as_bytes().windows(3).any(|win| win[0] == win[2])
-    }
 }
 
 #[test]
 fn test_nice() {
-    assert!( Day05::is_nice(&"qjhvhtzxzqqjkmpb".to_string()));
+    assert!( is_nice(&"qjhvhtzxzqqjkmpb".to_string()));
-    assert!( Day05::is_nice(&"xxyxx ".to_string()));
+    assert!( is_nice(&"xxyxx ".to_string()));
-    assert!(!Day05::is_nice(&"uurcxstgmygtbstg ".to_string()));
+    assert!(!is_nice(&"uurcxstgmygtbstg ".to_string()));
-    assert!(!Day05::is_nice(&"ieodomkazucvgmuy ".to_string()));
+    assert!(!is_nice(&"ieodomkazucvgmuy ".to_string()));
 }

rust/src/day_06.rs

@@ -1,23 +1,6 @@
-use std::io;
 use regex::Regex;
 
-use day::Day;
+pub fn solve(input: &str) -> i32 {
-
-pub struct Day06 {
-    input: String,
-}
-
-impl Day for Day06 {
-    fn new(input: String) -> Day06 {
-        Day06 { input: input }
-    }
-
-    fn solve(&self) -> io::Result<i32> {
-        Ok(solve(&self.input))
-    }
-}
-
-fn solve(input: &str) -> i32 {
     let mut lg = LightGrid::new();
 
     for line in input.lines() {

rust/src/lib.rs

@@ -1,17 +1,15 @@
 extern crate crypto;
 extern crate regex;
 
-macro_rules! import_day {
+macro_rules! pub_mod {
     ( $( $d:ident ),* ) => {
         $(
-            pub use $d::*;
+            pub mod $d;
-            mod $d;
         )*
     }
 }
 
-import_day! {
+pub_mod! {
-    day,
     day_01,
     day_02,
     day_03,

rust/src/main.rs

@@ -7,6 +7,5 @@ use advent_of_code::*;
 fn main() {
     let mut input = String::new();
     io::stdin().read_to_string(&mut input).ok();
-    let day = Day06::new(input);
+    println!("{}", day_06::solve(&input));
-    println!("{}", day.solve().unwrap());
 }