Rewrite old code into 2018 style.

Nice test for my 2018 repo set up. Which turns out needs some tweaking.

2016/src/day1.rs

@@ -0,0 +1,112 @@
+use std::io;
+use common;
+use std::collections::HashSet;
+use std::error::Error;
+
+
+fn dist(pos: (i32, i32)) -> i32 {
+    let (x, y) = pos;
+
+    return x.abs() + y.abs()
+}
+
+pub struct Day1 {
+    pos: (i32, i32),
+    dir: i32,
+}
+
+impl Day1 {
+    pub fn new() -> Day1 {
+        Day1{
+            pos: (0, 0),
+            dir: (0),
+        }
+    }
+
+    fn walk(&mut self) -> (i32, i32) {
+        let backwards = if self.dir & 2 == 2 { -1 } else { 1 };
+        let (x, y) = self.pos;
+
+        self.pos = (x + backwards * (1 - (self.dir & 1)), y + backwards * (self.dir & 1));
+        self.pos
+    }
+
+    fn turn(&mut self, action: &str) {
+        if action == "R" {
+            self.dir += 1;
+        } else {
+            self.dir += 3;
+        }
+        self.dir %= 4;
+    }
+}
+
+impl common::Solution for Day1 {
+    fn part1(&mut self, input: &mut io::Read) -> String {
+        let mut content = String::new();
+        match input.read_to_string(&mut content) {
+            Err(why) => panic!("couldn't open input: {}", why.description()),
+            Ok(_) => {},
+        };
+
+        for instruction in content.split(", ") {
+            let turn = &instruction[..1];
+            let steps: i32 = instruction[1..].trim().parse().expect("Invalid number of steps");
+            self.turn(turn);
+
+            for _ in 0..steps {
+                self.walk();
+            }
+        }
+
+        format!("{}", dist(self.pos))
+    }
+
+    fn part2(&mut self, input: &mut io::Read) -> String {
+        let mut content = String::new();
+        match input.read_to_string(&mut content) {
+            Err(why) => panic!("couldn't open input: {}", why.description()),
+            Ok(_) => {},
+        };
+
+        let mut positions = HashSet::new();
+        positions.insert(self.pos);
+
+        for instruction in content.split(", ") {
+            let turn = &instruction[..1];
+            let steps: i32 = instruction[1..].trim().parse().expect("Invalid number of steps");
+            self.turn(turn);
+
+            for _ in 0..steps {
+                let pos = self.walk();
+                if positions.contains(&pos) {
+                    return format!("{}", dist(pos))
+                } else {
+                    positions.insert(pos);
+                }
+            }
+        }
+
+        panic!("Never visited anything twice!")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Day1;
+    use common::Solution;
+
+    #[test]
+    fn sample_part1() {
+        let mut instance = Day1::new();
+
+        assert_eq!("8", instance.part1(&mut "R8, R4, R4, R8".as_bytes()))
+    }
+
+    #[test]
+    fn sample_part2() {
+        let mut instance = Day1::new();
+
+        assert_eq!("4", instance.part2(&mut "R8, R4, R4, R8".as_bytes()))
+    }
+}