feat(2018): refactor days 7-12 to use aoc-rust-common

Author: markkovari

2018/src/day07/mod.rs

@@ -1,18 +1,32 @@
 use aoc_rust_common::Solution;
 use std::fmt::Display;
 use std::collections::{HashMap, HashSet};
-use serde_scan::scan;
+use nom::{
+    bytes::complete::tag,
+    character::complete::anychar,
+    sequence::{preceded, separated_pair},
+    IResult,
+};
 
 pub struct Day07;
 
 type Step = char;
 
+fn parse_dependency(input: &str) -> IResult<&str, (Step, Step)> {
+    let (input, _) = tag("Step ")(input)?;
+    let (input, req) = anychar(input)?;
+    let (input, _) = tag(" must be finished before step ")(input)?;
+    let (input, step) = anychar(input)?;
+    let (input, _) = tag(" can begin.")(input)?;
+    Ok((input, (req, step)))
+}
+
 fn get_deps(input: &str) -> (HashSet<Step>, HashMap<Step, HashSet<Step>>) {
     let mut all_steps = HashSet::new();
     let mut requirements: HashMap<Step, HashSet<Step>> = HashMap::new();
 
     for line in input.lines() {
-        let (req, step): (Step, Step) = scan!("Step {} must be finished before step {} can begin." <- line).unwrap();
+        let (_, (req, step)) = parse_dependency(line).unwrap();
         all_steps.insert(req);
         all_steps.insert(step);
         requirements.entry(step).or_default().insert(req);
@@ -39,6 +53,8 @@ impl Solution for Day07 {
             if let Some(next_step) = available.first() {
                 ordered.push(*next_step);
                 done.insert(*next_step);
+            } else {
+                break; // No available steps
             }
         }
         Box::new(ordered)
@@ -56,7 +72,7 @@ impl Solution for Day07 {
                 .filter(|s| !done.contains(s) && !workers.iter().any(|&(_, w)| w == **s))
                 .filter(|s| requirements.get(s).map_or(true, |reqs| reqs.is_subset(&done)))
                 .copied().collect();
-            available.sort_unstable();
+            available.sort_unstable_by(|a, b| b.cmp(a)); // So we can pop from the end
 
             for (time_free, step) in workers.iter_mut().filter(|(tf, _)| *tf <= time) {
                  if *step != '.' { done.insert(*step); }
@@ -66,8 +82,20 @@ impl Solution for Day07 {
                     *time_free = time + base_duration + (next_step as u32 - 'A' as u32 + 1);
                 }
             }
-            time = workers.iter().filter(|&&(_, s)| s != '.').map(|(tf, _)| *tf).min().unwrap_or(time);
+            
+            let next_event_time = workers.iter().filter(|&&(_, s)| s != '.').map(|(tf, _)| *tf).min();
+            if let Some(t) = next_event_time {
+                time = t;
+            } else if !available.is_empty() {
+                // All workers are idle, but there are still steps to do. This can happen if we are waiting for a dependency.
+                // In this case, we need to advance time.
+                time += 1;
+            } else if done.len() == all_steps.len() {
+                break;
+            }
         }
-        Box::new(time)
+        
+        let final_time = workers.iter().map(|(tf, _)| *tf).max().unwrap_or(time);
+        Box::new(final_time)
     }
 }

2018/src/day12/mod.rs

@@ -49,7 +49,6 @@ fn run_simulation(initial_state: Vec<bool>, rules: [bool; 32], generations: i64)
     let mut zero_offset = 0i64;
 
     for _ in 0..generations {
-        let first_plant = state.iter().position(|&p| p).unwrap_or(0);
         let last_plant = state.iter().rposition(|&p| p).unwrap_or(0);
 
         let mut next_state = Vec::new();