2018 day 8

Author: ictrobot

crates/utils/src/parser/base.rs

@@ -355,7 +355,7 @@ pub trait Parser<'i>: Sized {
     fn parse_complete(&self, input: &'i str) -> Result<Self::Output, InputError> {
         match self.parse(input.as_bytes()).map_with_input(input)? {
             (v, []) => Ok(v),
-            (_, remaining) => Err(InputError::new(input, remaining, "expected end of input")),
+            (_, remaining) => Err(InputError::new(input, remaining, ParseError::ExpectedEof())),
         }
     }
 

crates/utils/src/parser/combinator.rs

@@ -198,7 +198,7 @@ impl<'i, P: Parser<'i>, S: Parser<'i>> Parser<'i> for RepeatVec<P, S> {
     fn parse_complete(&self, input: &'i str) -> Result<Self::Output, InputError> {
         match self.helper(input.as_bytes(), true).map_with_input(input)? {
             (v, []) => Ok(v),
-            (_, remaining) => Err(InputError::new(input, remaining, "expected end of input")),
+            (_, remaining) => Err(InputError::new(input, remaining, ParseError::ExpectedEof())),
         }
     }
 }

crates/utils/src/parser/error.rs

@@ -19,6 +19,8 @@ pub enum ParseError {
     ExpectedMatches(usize),
     /// Expected $n items or less.
     ExpectedLessItems(usize),
+    /// Expected end of input.
+    ExpectedEof(),
     /// Expected number <= $num.
     NumberTooLarge(i128),
     /// Expected number >= $num.
@@ -66,6 +68,7 @@ impl Display for ParseError {
                     max.escape_ascii().to_string(),
                 )
             }
+            ParseError::ExpectedEof() => write!(f, "expected end of input"),
             ParseError::ExpectedMatches(x) => write!(f, "expected at least {x} match"),
             ParseError::ExpectedLessItems(x) => write!(f, "expected {x} items or less"),
             ParseError::NumberTooLarge(x) => write!(f, "expected number <= {x}"),

crates/utils/src/parser/iterator.rs

@@ -37,6 +37,26 @@ impl<'a, P: Parser<'a>> Iterator for ParserIterator<'a, P> {
 
 impl<'a, P: Parser<'a>> FusedIterator for ParserIterator<'a, P> {}
 
+impl<'a, P: Parser<'a>> ParserIterator<'a, P> {
+    /// Returns the remaining input.
+    ///
+    /// # Examples
+    /// ```
+    /// # use utils::input::InputError;
+    /// # use utils::parser::{self, Parser};
+    /// let mut iterator = parser::u32()
+    ///     .with_suffix(parser::eol())
+    ///     .parse_iterator("12\n34\n56\n78");
+    /// assert_eq!(iterator.next().unwrap().unwrap(), 12);
+    /// assert_eq!(iterator.next().unwrap().unwrap(), 34);
+    /// assert_eq!(iterator.remaining(), b"56\n78");
+    /// ```
+    #[inline]
+    pub fn remaining(&self) -> &'a [u8] {
+        self.remaining
+    }
+}
+
 /// An iterator which returns successful parse outputs only, skipping over errors.
 ///
 /// See [`Parser::matches_iterator`].
@@ -64,3 +84,22 @@ impl<'a, P: Parser<'a>> Iterator for ParserMatchesIterator<'a, P> {
 }
 
 impl<'a, P: Parser<'a>> FusedIterator for ParserMatchesIterator<'a, P> {}
+
+impl<'a, P: Parser<'a>> ParserMatchesIterator<'a, P> {
+    /// Returns the remaining input.
+    ///
+    /// # Examples
+    /// ```
+    /// # use utils::input::InputError;
+    /// # use utils::parser::{self, Parser};
+    /// let mut iterator = parser::u32()
+    ///     .matches_iterator("abc123d456e7xyz");
+    /// assert_eq!(iterator.next().unwrap(), 123);
+    /// assert_eq!(iterator.next().unwrap(), 456);
+    /// assert_eq!(iterator.remaining(), b"e7xyz");
+    /// ```
+    #[inline]
+    pub fn remaining(&self) -> &'a [u8] {
+        self.remaining
+    }
+}

crates/utils/src/parser/simple.rs

@@ -138,7 +138,7 @@ impl<'i> Parser<'i> for Eof {
     fn parse(&self, input: &'i [u8]) -> ParseResult<'i, Self::Output> {
         match input {
             [] => Ok(((), input)),
-            _ => Err((ParseError::Expected("end of input"), input)),
+            _ => Err((ParseError::ExpectedEof(), input)),
         }
     }
 

crates/year2018/src/day08.rs

@@ -0,0 +1,94 @@
+use utils::parser::ParseError;
+use utils::prelude::*;
+
+/// Summing nested node metadata.
+#[derive(Clone, Debug)]
+pub struct Day08 {
+    part1: u32,
+    part2: u32,
+}
+
+impl Day08 {
+    pub fn new(input: &str, _: InputType) -> Result<Self, InputError> {
+        let mut iter = parser::u32()
+            .with_consumed()
+            .with_suffix(b' '.or(parser::eof()))
+            .parse_iterator(input);
+
+        let (part1, part2) = Self::parse_node(&mut |name, min_bound, max_bound| {
+            let min_bound = min_bound.unwrap_or(0);
+            let max_bound = max_bound.unwrap_or(u32::MAX);
+            match iter.next() {
+                None => Err(InputError::new(
+                    input,
+                    input.len(),
+                    ParseError::Expected(name),
+                )),
+                Some(Ok((n, pos))) if n < min_bound => Err(InputError::new(
+                    input,
+                    pos,
+                    ParseError::NumberTooSmall(min_bound.into()),
+                )),
+                Some(Ok((n, pos))) if n > max_bound => Err(InputError::new(
+                    input,
+                    pos,
+                    ParseError::NumberTooLarge(max_bound.into()),
+                )),
+                Some(Ok((n, _))) => Ok(n),
+                Some(Err(e)) => Err(e),
+            }
+        })?;
+
+        let remaining = iter.remaining();
+        if !remaining.is_empty() {
+            return Err(InputError::new(input, remaining, ParseError::ExpectedEof()));
+        }
+
+        Ok(Self { part1, part2 })
+    }
+
+    fn parse_node(
+        next: &mut impl FnMut(&'static str, Option<u32>, Option<u32>) -> Result<u32, InputError>,
+    ) -> Result<(u32, u32), InputError> {
+        let children = next("child count", None, Some(16))?;
+        let metadata = next("metadata count", Some(1), None)?;
+
+        let mut part1 = 0;
+        let mut child_values = [0; 16];
+        for i in 0..children {
+            let (p1, p2) = Self::parse_node(next)?;
+            part1 += p1;
+            child_values[i as usize] = p2;
+        }
+
+        let mut part2 = 0;
+        for _ in 0..metadata {
+            let e = next("metadata entry", None, None)?;
+            part1 += e;
+            part2 += child_values
+                .get(e.wrapping_sub(1) as usize)
+                .copied()
+                .unwrap_or(0);
+        }
+
+        if children == 0 {
+            part2 = part1;
+        }
+
+        Ok((part1, part2))
+    }
+
+    #[must_use]
+    pub fn part1(&self) -> u32 {
+        self.part1
+    }
+
+    #[must_use]
+    pub fn part2(&self) -> u32 {
+        self.part2
+    }
+}
+
+examples!(Day08 -> (u32, u32) [
+    {input: "2 3 0 3 10 11 12 1 1 0 1 99 2 1 1 2", part1: 138, part2: 66},
+]);

crates/year2018/src/lib.rs

@@ -9,4 +9,5 @@ utils::year!(2018 => year2018, ${
     5 => day05::Day05,
     6 => day06::Day06,
     7 => day07::Day07,
+    8 => day08::Day08,
 });