Solution for Advent of Code 2017 Day 9

day09.rs

use std::time::Instant;

const INPUT: &str = include_str!("inputs/day09.txt");

fn parse(input: &str) -> &str {
    input.trim()
}

fn p1(input: &str) -> usize {
    let input = parse(input);
    let mut score = 0;
    let mut depth = 0;
    let mut skip = false;
    let mut garbage = false;

    for c in input.chars() {
        match (skip, garbage, c) {
            (true, _, _) => skip = false,      // should we skip
            (_, _, '!') => skip = true,        // turn on skip
            (_, true, '>') => garbage = false, // leaving garbage
            (_, true, _) => {}                 // ignore in garbage
            (_, _, '<') => garbage = true,     // entering garbage
            (_, _, '{') => {
                // new group
                depth += 1;
                score += depth
            }
            (_, _, '}') => depth -= 1, // leaving group
            _ => {}
        }
    }

    score
}

fn p2(input: &str) -> usize {
    let input = parse(input);
    let mut skip = false;
    let mut garbage = false;
    let mut count = 0;

    for c in input.chars() {
        match (skip, garbage, c) {
            (true, _, _) => skip = false,      // should we skip
            (_, _, '!') => skip = true,        // turn on skip
            (_, true, '>') => garbage = false, // leaving garbage
            (_, true, _) => count += 1,        // count garbage
            (_, _, '<') => garbage = true,     // entering garbage
            _ => {}
        }
    }

    count
}

fn main() {
    let now = Instant::now();
    let solution = p1(INPUT);
    println!("p1 {:?} {}", now.elapsed(), solution);

    let now = Instant::now();
    let solution = p2(INPUT);
    println!("p2 {:?} {}", now.elapsed(), solution);
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_p1() {
        let inputs = [
            ("{}", 1),
            ("{{{}}},", 6),
            ("{{},{}},", 5),
            ("{{{},{},{{}}}},", 16),
            ("{<a>,<a>,<a>,<a>},", 1),
            ("{{<ab>},{<ab>},{<ab>},{<ab>}},", 9),
            ("{{<!!>},{<!!>},{<!!>},{<!!>}},", 9),
            ("{{<a!>},{<a!>},{<a!>},{<ab>}},", 3),
        ];
        inputs.iter().for_each(|(s, v)| assert_eq!(p1(s), *v));
    }

    #[test]
    fn test_p2() {
        let inputs = [
            ("{}", 0),
            ("{{{}}},", 0),
            ("{{},{}},", 0),
            ("{{{},{},{{}}}},", 0),
            ("{<a>,<a>,<a>,<a>},", 4),
            ("{{<ab>},{<ab>},{<ab>},{<ab>}},", 8),
            ("{{<!!>},{<!!>},{<!!>},{<!!>}},", 0),
        ];
        inputs.iter().for_each(|(s, v)| assert_eq!(p2(s), *v));
    }
}