Refactor to use common pos module

Author: timocp

src/pos.rs

@@ -162,17 +162,30 @@ impl fmt::Debug for Pos {
 
 impl fmt::Display for Pos {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "({},{})", self.x, self.y)
+        write!(f, "{},{}", self.x, self.y)
     }
 }
 
 // 3d position with x, y and z coordinates
+#[derive(Clone, Eq, Hash, PartialEq)]
 pub struct Pos3d {
     pub x: i32,
     pub y: i32,
     pub z: i32,
 }
 
+pub const ORIGIN3D: Pos3d = Pos3d { x: 0, y: 0, z: 0 };
+
+impl From<(i32, i32, i32)> for Pos3d {
+    fn from(xyz: (i32, i32, i32)) -> Self {
+        Pos3d {
+            x: xyz.0,
+            y: xyz.1,
+            z: xyz.2,
+        }
+    }
+}
+
 impl FromStr for Pos3d {
     type Err = ParseError;
 
@@ -196,6 +209,28 @@ impl FromStr for Pos3d {
     }
 }
 
+impl Add for &Pos3d {
+    type Output = Pos3d;
+    fn add(self, other: &Pos3d) -> Pos3d {
+        Pos3d {
+            x: self.x + other.x,
+            y: self.y + other.y,
+            z: self.z + other.z,
+        }
+    }
+}
+
+impl Sub for &Pos3d {
+    type Output = Pos3d;
+    fn sub(self, other: &Pos3d) -> Pos3d {
+        Pos3d {
+            x: self.x - other.x,
+            y: self.y - other.y,
+            z: self.z - other.z,
+        }
+    }
+}
+
 impl Pos3d {
     #[allow(dead_code)]
     // manhattan distance between points

src/y2018/day13.rs

@@ -1,12 +1,13 @@
+use crate::pos::Pos;
 use std::fmt;
 use std::fmt::Write;
 
 pub fn part1(mine: &Mine) -> String {
-    format!("{:?}", mine.clone().first_crash())
+    mine.clone().first_crash().to_string()
 }
 
 pub fn part2(mine: &Mine) -> String {
-    format!("{:?}", mine.clone().last_cart())
+    mine.clone().last_cart().to_string()
 }
 
 #[derive(Clone)]
@@ -69,22 +70,9 @@ enum Turn {
     Right,
 }
 
-#[derive(PartialEq)]
-struct Position {
-    x: usize,
-    y: usize,
-}
-
-impl fmt::Debug for Position {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{},{}", self.x, self.y)
-    }
-}
-
 #[derive(Debug, Clone)]
 struct Cart {
-    x: usize,
-    y: usize,
+    pos: Pos,
     facing: Direction,
     next_turn: Turn,
     destroyed: bool,
@@ -112,13 +100,13 @@ impl Cart {
 
     fn move_turn(&mut self, map: &[Vec<Cell>]) {
         match self.facing {
-            Direction::North => self.y -= 1,
-            Direction::East => self.x += 1,
-            Direction::South => self.y += 1,
-            Direction::West => self.x -= 1,
+            Direction::North => self.pos.y -= 1,
+            Direction::East => self.pos.x += 1,
+            Direction::South => self.pos.y += 1,
+            Direction::West => self.pos.x -= 1,
         }
 
-        match map[self.y][self.x] {
+        match map[self.pos.y as usize][self.pos.x as usize] {
             Cell::Corner1 => match self.facing {
                 Direction::North => self.facing = Direction::East,
                 Direction::East => self.facing = Direction::North,
@@ -148,7 +136,10 @@ impl fmt::Debug for Mine {
         let mut i = 0;
         for (y, row) in self.map.iter().enumerate() {
             for (x, cell) in row.iter().enumerate() {
-                if i < self.carts.len() && self.carts[i].y == y && self.carts[i].x == x {
+                if i < self.carts.len()
+                    && self.carts[i].pos.y == y as i32
+                    && self.carts[i].pos.x == x as i32
+                {
                     f.write_char(self.carts[i].facing.to_char()).unwrap();
                     i += 1;
                 } else {
@@ -162,39 +153,38 @@ impl fmt::Debug for Mine {
 }
 
 impl Mine {
-    fn first_crash(&mut self) -> Position {
+    fn first_crash(&mut self) -> Pos {
         loop {
             for cart_id in 0..self.carts.len() {
                 self.carts[cart_id].move_turn(&self.map);
 
                 // has it crashed?
                 if self.detect_crash(cart_id) {
-                    return Position {
-                        x: self.carts[cart_id].x,
-                        y: self.carts[cart_id].y,
+                    return Pos {
+                        x: self.carts[cart_id].pos.x,
+                        y: self.carts[cart_id].pos.y,
                     };
                 }
             }
-            self.carts.sort_by_key(|c| (c.y, c.x));
+            self.carts.sort_by_key(|c| (c.pos.y, c.pos.x));
         }
     }
 
     fn detect_crash(&mut self, this_id: usize) -> bool {
-        let this_x = self.carts[this_id].x;
-        let this_y = self.carts[this_id].y;
+        let this_pos = self.carts[this_id].pos;
         for (other_id, other) in self.carts.iter_mut().enumerate() {
             if other_id == this_id {
                 continue;
             }
-            if this_x == other.x && this_y == other.y {
+            if this_pos == other.pos {
                 other.destroyed = true;
                 return true;
             }
         }
         false
     }
 
-    fn last_cart(&mut self) -> Position {
+    fn last_cart(&mut self) -> Pos {
         loop {
             for cart_id in 0..self.carts.len() {
                 self.carts[cart_id].move_turn(&self.map);
@@ -205,12 +195,9 @@ impl Mine {
             }
             self.carts.retain(|cart| !cart.destroyed);
             if self.carts.len() == 1 {
-                return Position {
-                    x: self.carts[0].x,
-                    y: self.carts[0].y,
-                };
+                return self.carts[0].pos;
             }
-            self.carts.sort_by_key(|c| (c.y, c.x));
+            self.carts.sort_by_key(|c| (c.pos.y, c.pos.x));
         }
     }
 }
@@ -236,8 +223,10 @@ pub fn parse_input(input: &str) -> Mine {
                     mine.map[y][x] = Cell::EW;
                 }
                 mine.carts.push(Cart {
-                    x,
-                    y,
+                    pos: Pos {
+                        x: x as i32,
+                        y: y as i32,
+                    },
                     facing: Direction::from_char(c).unwrap(),
                     next_turn: Turn::Left,
                     destroyed: false,
@@ -275,12 +264,12 @@ mod tests {
     #[test]
     fn test_first_crash() {
         let mut mine = parse_input(test_input());
-        assert_eq!(Position { x: 7, y: 3 }, mine.first_crash());
+        assert_eq!(Pos { x: 7, y: 3 }, mine.first_crash());
     }
 
     #[test]
     fn test_last_cart() {
         let mut mine = parse_input(test_input2());
-        assert_eq!(Position { x: 6, y: 4 }, mine.last_cart());
+        assert_eq!(Pos { x: 6, y: 4 }, mine.last_cart());
     }
 }

src/y2018/day6.rs

@@ -99,15 +99,7 @@ fn box_size(coords: &[Pos]) -> (Pos, Pos) {
 }
 
 pub fn parse_input(input: &str) -> Vec<Pos> {
-    let mut list = vec![];
-    for line in input.lines() {
-        let coords: Vec<_> = line.split(", ").filter_map(|s| s.parse().ok()).collect();
-        list.push(Pos {
-            x: coords[0],
-            y: coords[1],
-        });
-    }
-    list
+    input.lines().map(|s| s.parse().unwrap()).collect()
 }
 
 #[test]