Change AoC result to allow a vec of results

- also formatted day 14

Author: OrangeBacon

libaoc/src/lib.rs

@@ -1,8 +1,7 @@
 #![feature(str_split_once)]
 
 use anyhow::{Error, Result};
-use std::fmt;
-use std::string::ToString;
+use std::{cmp::max, fmt, string::ToString};
 
 mod vm;
 pub use vm::*;
@@ -40,16 +39,20 @@ pub fn get_solution(solutions: &'static [Solution], day: usize) -> Result<&Solut
 
 /// generic result container for each day
 pub struct AocResult {
-    pub part1: String,
-    pub part2: String,
+    results: Vec<(&'static str, String)>,
 }
 
 impl AocResult {
     /// construct result from any valid types
     pub fn new<T: ToString, R: ToString>(part1: T, part2: R) -> Self {
         AocResult {
-            part1: part1.to_string(),
-            part2: part2.to_string(),
+            results: vec![("Part 1", part1.to_string()), ("Part 2", part2.to_string())],
+        }
+    }
+
+    pub fn from(results: &[(&'static str, String)]) -> Self {
+        AocResult {
+            results: results.to_vec()
         }
     }
 }
@@ -95,14 +98,35 @@ impl fmt::Display for FloatTime {
 
 impl fmt::Display for AocResult {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        write!(f, "{}, {}", self.part1, self.part2)
+        for (i, result) in self.results.iter().enumerate() {
+            if i > 0 {
+                write!(f, ", ")?;
+            }
+            write!(f, "{}", result.1)?;
+        }
+        Ok(())
     }
 }
 
 impl fmt::Debug for AocResult {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         writeln!(f, "Results:")?;
-        writeln!(f, "  Part 1: {}", self.part1)?;
-        writeln!(f, "  Part 2: {}", self.part2)
+
+        let width = self
+            .results
+            .iter()
+            .fold(0, |acc, (name, _)| max(acc, name.len()))
+            + 1;
+
+        for (name, result) in &self.results {
+            writeln!(
+                f,
+                "  {:<width$} {}",
+                format!("{}:", name),
+                result,
+                width = width
+            )?;
+        }
+        Ok(())
     }
 }

src/days/day14.rs

@@ -1,7 +1,7 @@
 use anyhow::Result;
+use hashbrown::HashMap;
 use libaoc::{aoc, AocResult, Timer};
 use regex::Regex;
-use hashbrown::HashMap;
 
 #[derive(Debug)]
 enum Command {
@@ -15,25 +15,28 @@ pub fn solve(timer: &mut Timer, input: String) -> Result<AocResult> {
     let mem_reg = Regex::new(r"mem\[(\d+)\] = (\d+)")?;
     let mask_reg = Regex::new(r"mask = ([X01]+)")?;
 
-    let lines: Vec<_> = input.lines().map(|x| {
-        if let Some(cap) = mem_reg.captures(x) {
-            Mem(cap[1].parse().unwrap(), cap[2].parse().unwrap())
-        } else {
-            let cap = mask_reg.captures(x).unwrap();
-            let mut zero_mask = 0;
-            let mut one_mask = 0;
-            let mut x_mask = vec![];
-            for (i,c) in cap[1].chars().rev().enumerate() {
-                match c {
-                    '0' => zero_mask |= 1 << i,
-                    '1' => one_mask |= 1 << i,
-                    'X' => x_mask.push(i),
-                    _ => ()
+    let lines: Vec<_> = input
+        .lines()
+        .map(|x| {
+            if let Some(cap) = mem_reg.captures(x) {
+                Mem(cap[1].parse().unwrap(), cap[2].parse().unwrap())
+            } else {
+                let cap = mask_reg.captures(x).unwrap();
+                let mut zero_mask = 0;
+                let mut one_mask = 0;
+                let mut x_mask = vec![];
+                for (i, c) in cap[1].chars().rev().enumerate() {
+                    match c {
+                        '0' => zero_mask |= 1 << i,
+                        '1' => one_mask |= 1 << i,
+                        'X' => x_mask.push(i),
+                        _ => (),
+                    }
                 }
+                Mask(!zero_mask, one_mask, x_mask)
             }
-            Mask(!zero_mask,one_mask,x_mask)
-        }
-    }).collect();
+        })
+        .collect();
 
     timer.lap("Parse");
 
@@ -42,12 +45,12 @@ pub fn solve(timer: &mut Timer, input: String) -> Result<AocResult> {
     let mut mem = HashMap::new();
     for line in &lines {
         match line {
-            Mask(a,b,_) => {
+            Mask(a, b, _) => {
                 zero_mask = *a;
                 one_mask = *b;
             }
-            Mem(a,b) => {
-                mem.insert(a, (b|one_mask)&zero_mask);
+            Mem(a, b) => {
+                mem.insert(a, (b | one_mask) & zero_mask);
             }
         }
     }
@@ -60,7 +63,7 @@ pub fn solve(timer: &mut Timer, input: String) -> Result<AocResult> {
     let mut mem = HashMap::new();
     for line in &lines {
         match line {
-            Mask(_,b,c) => {
+            Mask(_, b, c) => {
                 one_mask = *b;
                 x_mask = c;
             }
@@ -70,7 +73,7 @@ pub fn solve(timer: &mut Timer, input: String) -> Result<AocResult> {
                     let mut addr = addr;
                     for (i, addr_index) in x_mask.iter().enumerate() {
                         if (curr_change & (1 << i)) != 0 {
-                            addr &= !(1<<addr_index);
+                            addr &= !(1 << addr_index);
                         } else {
                             addr |= 1 << addr_index;
                         }