day8: problem 1 & 2 solutions

8/src/main.rs

@@ -0,0 +1,171 @@
+use std::collections::HashMap;
+use std::fs::File;
+use std::io::{BufRead, BufReader, Lines};
+
+use lazy_regex::{lazy_regex, Lazy, Regex};
+
+// BOILERPLATE
+type InputIter = Lines<BufReader<File>>;
+
+fn get_input() -> InputIter {
+    let f = File::open("input").unwrap();
+    let br = BufReader::new(f);
+    br.lines()
+}
+
+fn main() {
+    println!("Problem 1 solution: {}", problem1(get_input()));
+    println!("Problem 2 solution: {}", problem2(get_input()));
+}
+
+// PARSE
+
+const LINE_REGEX: Lazy<Regex> = lazy_regex!(r"([A-Z0-9]{3}) = \(([A-Z0-9]{3}), ([A-Z0-9]{3})\)");
+
+enum Instruction {
+    LEFT,
+    RIGHT,
+}
+
+impl From<char> for Instruction {
+    fn from(c: char) -> Self {
+        match c {
+            'L' => Self::LEFT,
+            'R' => Self::RIGHT,
+            _ => panic!("Invalid instruction"),
+        }
+    }
+}
+
+#[derive(Debug)]
+struct Element {
+    left: String,
+    right: String,
+}
+
+type Nodes = HashMap<String, Element>;
+
+#[derive(Debug)]
+struct Map {
+    instructions: Vec<char>,
+    nodes: Nodes,
+}
+
+fn parse_node(nodes: &mut Nodes, node: &str) {
+    let matches = LINE_REGEX.captures(node).unwrap();
+
+    let node_id = matches.get(1).unwrap().as_str();
+    let left = matches.get(2).unwrap().as_str();
+    let right = matches.get(3).unwrap().as_str();
+
+    nodes.insert(
+        node_id.to_string(),
+        Element {
+            left: left.to_string(),
+            right: right.to_string(),
+        },
+    );
+}
+
+impl<T: BufRead> From<Lines<T>> for Map {
+    fn from(mut lines: Lines<T>) -> Self {
+        let instructions = lines.next().unwrap().unwrap().chars().collect();
+        let mut nodes = HashMap::new();
+        lines.next();
+        for line in lines {
+            parse_node(&mut nodes, line.unwrap().as_str());
+        }
+
+        Self {
+            instructions,
+            nodes,
+        }
+    }
+}
+
+// PROBLEM 1 solution
+
+fn problem1<T: BufRead>(input: Lines<T>) -> u64 {
+    let map = Map::from(input);
+
+    let mut count = 0;
+    let mut cur_node = "AAA";
+    for side in map.instructions.iter().cycle() {
+        count += 1;
+        cur_node = match side {
+            'L' => &map.nodes[cur_node].left,
+            'R' => &map.nodes[cur_node].right,
+            _ => panic!("invalid instruction"),
+        };
+        if cur_node == "ZZZ" {
+            return count;
+        }
+    }
+
+    0
+}
+
+fn node_cycle_length(map: &Map, node: &str) -> u64 {
+    let mut count = 0;
+    let mut cur_node = node;
+    for side in map.instructions.iter().cycle() {
+        count += 1;
+        cur_node = match side {
+            'L' => &map.nodes[cur_node].left,
+            'R' => &map.nodes[cur_node].right,
+            _ => panic!("invalid instruction"),
+        };
+        if cur_node.ends_with('Z') {
+            return count;
+        }
+    }
+    0
+}
+
+// PROBLEM 2 solution
+fn problem2<T: BufRead>(input: Lines<T>) -> u64 {
+    let map = Map::from(input);
+
+    let starting_nodes: Vec<_> = map.nodes.keys().filter(|s| s.ends_with('A')).collect();
+
+    starting_nodes.iter().map(|n| node_cycle_length(&map, *n)).fold(1, |accum, elem| num::integer::lcm(accum, elem))
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::*;
+    use std::io::Cursor;
+
+    const EXAMPLE: &str = &"RL
+
+AAA = (BBB, CCC)
+BBB = (DDD, EEE)
+CCC = (ZZZ, GGG)
+DDD = (DDD, DDD)
+EEE = (EEE, EEE)
+GGG = (GGG, GGG)
+ZZZ = (ZZZ, ZZZ)";
+
+    const EXAMPLE2: &str = &"LR
+
+11A = (11B, XXX)
+11B = (XXX, 11Z)
+11Z = (11B, XXX)
+22A = (22B, XXX)
+22B = (22C, 22C)
+22C = (22Z, 22Z)
+22Z = (22B, 22B)
+XXX = (XXX, XXX)";
+
+    #[test]
+    fn problem1_example() {
+        let c = Cursor::new(EXAMPLE);
+        assert_eq!(problem1(c.lines()), 2);
+    }
+
+    #[test]
+    fn problem2_example() {
+        let c = Cursor::new(EXAMPLE2);
+        assert_eq!(problem2(c.lines()), 6);
+    }
+}