init

src/day3/main.rs

@@ -0,0 +1,94 @@
+use std::collections::HashSet;
+use std::io::{self, BufRead};
+
+#[derive(Debug)]
+enum Step {
+	Up(usize),
+	Down(usize),
+	Left(usize),
+	Right(usize),
+}
+
+impl Step {
+	fn draw(&self, map: &mut HashSet<Point>, start: &mut Point) {
+		let mover: (i64, i64, &usize) = match self {
+			Step::Up(s) => (0, 1, s),
+			Step::Down(s) => (0, -1, s),
+			Step::Left(s) => (-1, 0, s),
+			Step::Right(s) => (1, 0, s),
+		};
+		let (x, y, steps) = mover;
+		map.reserve(*steps);
+		for _ in 0..*steps {
+			start.x += x;
+			start.y += y;
+			map.insert(start.clone());
+		}
+	}
+}
+
+impl From<&[u8]> for Step {
+	fn from(b: &[u8]) -> Self {
+		let steps: usize = b[0..]
+			.iter()
+			.filter(|i| **i >= b'0' && **i <= b'9')
+			.fold(0, |s, i| ((i - b'0') as usize + 10 * s));
+		match b[0] {
+			b'U' => Step::Up(steps),
+			b'D' => Step::Down(steps),
+			b'L' => Step::Left(steps),
+			b'R' => Step::Right(steps),
+			_ => panic!("unknown directions"),
+		}
+	}
+}
+
+#[derive(Eq, PartialEq, Hash, Clone, Copy, Debug)]
+struct Point {
+	x: i64,
+	y: i64,
+}
+
+impl Point {
+	fn dist_to_00(&self) -> u64 {
+		(self.x.abs() + self.y.abs()) as u64
+	}
+}
+
+impl From<(i64, i64)> for Point {
+	fn from(xy: (i64, i64)) -> Self {
+		Point { x: xy.0, y: xy.1 }
+	}
+}
+
+fn main() -> io::Result<()> {
+	let commands = load();
+	let mut wires: Vec<HashSet<Point>> = vec![];
+	commands.iter().enumerate().for_each(|(_, wire)| {
+		let mut map = HashSet::new();
+		let mut p: Point = (0, 0).into();
+		wire.iter().for_each(|step| {
+			step.draw(&mut map, &mut p);
+		});
+		wires.push(map);
+	});
+	let closest = wires[0].intersection(&wires[1]).fold(None, |min, point| {
+		let dist = point.dist_to_00();
+		match min {
+			None => Some(dist),
+			Some(min) => Some(if dist < min { dist } else { min }),
+		}
+	});
+	println!("closest: {}", closest.unwrap());
+	Ok(())
+}
+
+fn load() -> Vec<Vec<Step>> {
+	let stdin = io::stdin();
+	stdin
+		.lock()
+		.split(b'\n')
+		.filter_map(|i| i.ok())
+		.map(|line| line.split(|b| *b == b',').map(|i| Step::from(i)).collect())
+		.collect()
+}