Advent of Code 2022 - Day 21
Tags: adventofcode, programming, rust
Published: 2022-12-28 15:49:18

---
title: Advent of Code 2022 - Day 21
published: true
date: 2022-12-25 00:00:00 UTC
tags: adventofcode, programming, rust
canonical_url: https://www.ericburden.work/blog/2022/12/25/advent-of-code-2022-day-21/
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/k1uoyukeemj8p28fz2cb.png
---

It’s that time of year again! Just like last year, I’ll be posting my solutions to the [Advent of Code](https://adventofcode.com/) puzzles. This year, I’ll be solving the puzzles in [Rust](https://www.rust-lang.org/). I’ll post my solutions and code to [GitHub](https://github.com/ericwburden/advent_of_code_2022) as well. After finishing last year (and 2015-2019) in [Julia](https://julialang.org/), I needed to spend some time with Rust again! If you haven’t given AoC a try, I encourage you to do so along with me!

# Day 21 - Monkey Math

Find the problem description [HERE](https://adventofcode.com/2022/day/21).

## The Input - Weird Expressions

Input parsing is the real heavy lift of today’s puzzle. Now, if we were running Python or Julia or some such, we could use `eval()` or similar on the inputs until we get an answer, but where’s the fun in that? Instead, let’s simulate a context-free grammar and parse these monkey math expressions into something that looks a bit like an R _environment_. Could probably have actually gone all the way to an abstract syntax tree, but nesting structs is a bit of a pain in Rust. Instead, we’ll store each expression in a `HashMap` under the name of the monkey left of the assignment operator, with an `Expression` as the value. It’s not so much that there’s an excessive amount of parsing today as the data structures we’re using are pretty specific.

```rust
use anyhow::{bail, Error};
use std::collections::HashMap;

/// Represents the names of each monkey. I originally wanted to use
/// string references as the monkey labels, but that causes borrow
/// checker issues with mutating the Environment (defined below),
/// so I'm using a small, cheap array of characters instead.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct Label([char; 4]);

/// Try to convert a string slice to a Label. Only works for string
/// slices with exactly four characters.
impl TryFrom<&str> for Label {
    type Error = Error;

    fn try_from(value: &str) -> Result<Self, Self::Error> {
        if value.len() != 4 {
            bail!("Can only convert a 4-character string to Label")
        }
        let mut out = ['\0'; 4];
        for (idx, ch) in value.chars().enumerate() {
            out[idx] = ch;
        }
        Ok(Label(out))
    }
}

/// Represents a Value being passed from monkey to monkey. Either a reference
/// to another monkey, or a raw number.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Value {
    Ref(Label), // reference
    Raw(i128), // raw number
}

/// Converts a string slice into a Value::Ref. Just convenient to have.
impl TryFrom<&str> for Value {
    type Error = Error;

    fn try_from(value: &str) -> Result<Self, Self::Error> {
        Ok(Value::Ref(Label::try_from(value)?))
    }
}

/// Represents one of the mathematical expressions being evaluated by a
/// monkey. Every monkey is evaluating an expression, even if it's just
/// to report a value.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Expression {
    Add(Value, Value),
    Sub(Value, Value),
    Mul(Value, Value),
    Div(Value, Value),
    Val(Value),
}

/// Represents the environment in which monkey math is being evaluated. Keeps
/// track of each variable (monkey) and their current assigned Expression.
#[derive(Debug, Clone)]
struct Environment(HashMap<Label, Expression>);

/// Wraps the parsing functions for today's input.
mod parser {
    use super::*;
    use anyhow::{anyhow, Result};
    use nom::{
        branch::alt,
        bytes::complete::tag,
        character::complete::{alpha1, i128, newline},
        combinator::{map, map_res, verify},
        multi::separated_list0,
        sequence::separated_pair,
        Finish, IResult,
    };

    /// Nom parser for "humn" -> Label(['h', 'u', 'm', 'n'])
    fn label(s: &str) -> IResult<&str, Label> {
        map_res(alpha1, Label::try_from)(s)
    }

    /// Nom parser for "humn" -> Value::Ref(Label(['h', 'u', 'm', 'n']))
    fn value_ref(s: &str) -> IResult<&str, Value> {
        map(label, Value::Ref)(s)
    }

    /// Nom parser for "15" -> Value::Raw(15)
    fn value_raw(s: &str) -> IResult<&str, Value> {
        map(i128, Value::Raw)(s)
    }

    /// Nom parser for monkey addition expressions
    fn expr_add(s: &str) -> IResult<&str, (Label, Expression)> {
        let (s, lbl) = label(s)?;
        let (s, _) = tag(": ")(s)?;
        let (s, (v1, v2)) = separated_pair(value_ref, tag(" + "), value_ref)(s)?;
        Ok((s, (lbl, Expression::Add(v1, v2))))
    }

    /// Nom parser for monkey subtraction expressions
    fn expr_sub(s: &str) -> IResult<&str, (Label, Expression)> {
        let (s, lbl) = label(s)?;
        let (s, _) = tag(": ")(s)?;
        let (s, (v1, v2)) = separated_pair(value_ref, tag(" - "), value_ref)(s)?;
        Ok((s, (lbl, Expression::Sub(v1, v2))))
    }

    /// Nom parser for monkey multiplication expressions
    fn expr_mul(s: &str) -> IResult<&str, (Label, Expression)> {
        let (s, lbl) = label(s)?;
        let (s, _) = tag(": ")(s)?;
        let (s, (v1, v2)) = separated_pair(value_ref, tag(" * "), value_ref)(s)?;
        Ok((s, (lbl, Expression::Mul(v1, v2))))
    }

    /// Nom parser for monkey division expressions
    fn div_expr(s: &str) -> IResult<&str, (Label, Expression)> {
        let (s, lbl) = label(s)?;
        let (s, _) = tag(": ")(s)?;
        let (s, (v1, v2)) = separated_pair(value_ref, tag(" / "), value_ref)(s)?;
        Ok((s, (lbl, Expression::Div(v1, v2))))
    }

    /// Nom parser for monkey value expressions
    fn val_expr(s: &str) -> IResult<&str, (Label, Expression)> {
        let (s, lbl) = label(s)?;
        let (s, _) = tag(": ")(s)?;
        let (s, value) = value_raw(s)?;
        Ok((s, (lbl, Expression::Val(value))))
    }

    /// Nom parser for all variants of an Expression
    fn expression(s: &str) -> IResult<&str, (Label, Expression)> {
        alt((val_expr, expr_add, expr_sub, expr_mul, div_expr))(s)
    }

    /// Nom parser for a newline-separated list of Expressions
    fn expressions(s: &str) -> IResult<&str, HashMap<Label, Expression>> {
        let (s, exprs) = separated_list0(newline, expression)(s)?;
        let exprs = exprs.into_iter().collect::<HashMap<_, _>>();
        Ok((s, exprs))
    }

    /// Parses the input file into an Environment
    fn parse(s: &str) -> Result<Environment> {
        let (_, result) = expressions(s).finish().map_err(|e| anyhow!("{e}"))?;
        Ok(Environment(result))
    }
}

const INPUT: &str = include_str!("../../input/21/input.txt");

/// Parse that input!
fn read() -> Environment {
    parser::parse(INPUT).unwrap()
}

```

My first pass through today’s puzzle kept string slices that referred to the input as the `Environment` keys, which worked fine for part one. In part two (spoiler alert), I ended up wanting to modify the `Environment`, which created a bunch of lifetime pain. I _probably_ could have gotten around that with a `Cow<&str>`, but the little array labels worked just as well.

## Part One - King Kalculus

Oh, goodness, it’s the monkeys again! Well, at least this time we have elephants to translate for us so we can communicate with the monkeys instead of simply screaming at them in frustration until we black out. Ah, good times… Anyway, looks like this time the monkeys are trying to be helpful. Well, really, more like “trying”, since it’s entirely possible they could just point us in the right direction without this riddle-solving business. Good thing we like riddles…

```rust
/// Solve Day 21, Part 1
fn solve(input: &Environment) -> i128 {
    let root = Value::try_from("root").unwrap();
    root.eval(input).unwrap()
}

/// Fetch an Expression from the Environment by Label
impl Environment {
    fn resolve(&self, var: &Label) -> Option<Expression> {
        self.0.get(var).copied()
    }
}

/// Trait for evaluating an Expression in an Environment
trait Eval {
    fn eval(&self, env: &Environment) -> Option<i128>;
}

impl Eval for Value {
    /// Recursively evaluate the Value until a Value::Raw can be returned
    fn eval(&self, env: &Environment) -> Option<i128> {
        match self {
            Value::Ref(var) => env.resolve(var).and_then(|v| v.eval(env)),
            Value::Raw(val) => Some(*val),
        }
    }
}

impl Eval for Expression {
    /// Recursively evaluate the Value until a Value::Raw can be returned
    fn eval(&self, env: &Environment) -> Option<i128> {
        // Perform operations based on the type of Expression
        match self {
            Expression::Add(v1, v2) => Some(v1.eval(env)? + v2.eval(env)?),
            Expression::Sub(v1, v2) => Some(v1.eval(env)? - v2.eval(env)?),
            Expression::Mul(v1, v2) => Some(v1.eval(env)? * v2.eval(env)?),
            Expression::Div(v1, v2) => Some(v1.eval(env)? / v2.eval(env)?),
            Expression::Val(value) => value.eval(env),
        }
    }
}

```

Ok, that was a really big number that “root” monkey just added up entirely in his head. I’m starting to wonder whether this whole “translation” thing is entirely necessary. I bet that monkey can speak English, too. They’re probably just humoring the elephants: “Oh, yes, your pronunciation is just fine.” they say.

## Part Two - Mass Communication Mishap

Except, as it turns out, the elephants’ pronunciation of _monkey_ isn’t actually all that good. Or maybe it’s our ability to understand _elephant_. Either way, it looks like we’re participating in this game. We’ll need to figure out what number to shout to get the “root” monkey to have two equal numbers to compare. The good news is that the number of monkeys waiting with bated breath to hear our number is actually pretty small, so only one side of the comparison changes depending on what we shout. This cuts down on the potential complexity _a lot_.

```rust
fn solve(input: &Environment) -> i128 {
    use Expression::*;
    use Value::*;

    // Eject the assignment to the "humn" variable from the environment.
    // We'll be calculating that.
    let mut env = input.clone();
    let humn_lbl = Label::try_from("humn").unwrap();
    env.remove(&humn_lbl);

    // Since the "root" monkey is supposed to check two numbers for equality,
    // let's get the two variables that the boss monkey will be checking and
    // determine what we get if we try to evaluate them.
    let root_lbl = Label::try_from("root").unwrap();
    let Add(left, right) = env.resolve(&root_lbl).unwrap() else { panic!("No root monkey!"); };

    // The PartialEval trait attempts to evaluate the calling expression and
    // updates each variable in the environment that can be evalutated along
    // the way. From this point forward, every variable in the environment
    // that doesn't depend on "humn" will be a raw value instead of an expression
    // containing references.
    let left_val = left.partial_eval(&mut env);
    let right_val = right.partial_eval(&mut env);

    // Turns out, from examining the input, there's only one path that depends
    // on the "humn" variable. This means that one of the two variables being
    // checked will be constant and the other will depend on the value of
    // "humn". So. let's check what we got from evaluating the left and right
    // variables and see which one returned an actual value. That will be the
    // value we start adjusting moving forward. The other variable value will
    // represent the formula we need to solve.
    let (mut carry, mut next_op) = match (left_val, right_val) {
        (lhs, Val(Raw(val))) => (val, Some(lhs)),
        (Val(Raw(val)), rhs) => (val, Some(rhs)),
        _ => unreachable!(),
    };

    // Since we know that both values checked by the "root" monkey must be equal,
    // then we know enough to start solving each expression from `next_op` all
    // the way to the value of "humn". For example, say we had the following
    // set of relationships:
    //
    // - root = 5 == abcd (5)
    // - abcd = 10 - efgh -> 5 = 10 - efgh -> efgh = 10 - 5 -> efgh = 5
    // - efgh = 60 / ijkl -> 5 = 60 / ijkl -> ijkl = 60 / 5 -> ijkl = 12
    // - ijkl = 3 * humn -> 12 = 3 * humn -> humn = 12 / 3 -> humn = 4
    //
    // Thus, we can calculate the value of "humn" by substituting values into
    // formulae and solving by rearrangement one formula at a time until we
    // find the value of "humn".
    while let Some(expr) = next_op {
        // Rearrange the expressions based on the value we're carrying forward and
        // the type of operation being performed. There's a lot of "unreachable"
        // points along the way that are possible because we know that every
        // variable that doesn't depend on "humn" has already been fully evaluated.
        (carry, next_op) = match expr {
            Add(lhs, rhs) => match (lhs, rhs) {
                (Ref(lhs), Raw(val)) => (carry - val, env.resolve(&lhs)),
                (Raw(val), Ref(rhs)) => (carry - val, env.resolve(&rhs)),
                (_, _) => unreachable!(),
            },
            Sub(lhs, rhs) => match (lhs, rhs) {
                (Ref(lhs), Raw(val)) => (val + carry, env.resolve(&lhs)),
                (Raw(val), Ref(rhs)) => (val - carry, env.resolve(&rhs)),
                (_, _) => unreachable!(),
            },
            Mul(lhs, rhs) => match (lhs, rhs) {
                (Ref(lhs), Raw(val)) => (carry / val, env.resolve(&lhs)),
                (Raw(val), Ref(rhs)) => (carry / val, env.resolve(&rhs)),
                (_, _) => unreachable!(),
            },
            Div(lhs, rhs) => match (lhs, rhs) {
                (Ref(lhs), Raw(val)) => (val * carry, env.resolve(&lhs)),
                (Raw(val), Ref(rhs)) => (val / carry, env.resolve(&rhs)),
                (_, _) => unreachable!(),
            },
            Val(_) => unreachable!(),
        };
    }

    carry.into()
}

/// Remove an expression from the Environment based on Label
impl Environment {
    fn remove(&mut self, label: &Label) -> Option<Expression> {
        self.0.remove(label)
    }
}

/// This trait is used to evaluate Expressions in an Environment, updating
/// the Environment whenever a variable is evaluated. Going forward, the
/// Environment will have variables as fully evaluated as possible upon
/// which the expression that calls PartialEval depends.
trait PartialEval {
    fn partial_eval(&self, env: &mut Environment) -> Expression;
}

impl PartialEval for Value {
    fn partial_eval(&self, env: &mut Environment) -> Expression {
        use Expression::*;
        use Value::*;

        match self {
            // This is where the magic happens. Every time a reference is
            // successfully evaluated, update the Environment with its new
            // value.
            Ref(var) => {
                let Some(expr) = env.resolve(var) else { return Val(*self); };
                let eval = expr.partial_eval(env);
                env.0.insert(*var, eval);
                eval
            }
            _ => Val(*self),
        }
    }
}

impl PartialEval for Expression {
    fn partial_eval(&self, env: &mut Environment) -> Expression {
        use Expression::*;
        use Value::*;

        // For each type of expression, if it can be fully evaluated, do so. If
        // only one side can be evaluated, evaluate that one and retain the other
        // as-is.
        match self {
            Add(v1, v2) => match (v1.partial_eval(env), v2.partial_eval(env)) {
                (Val(Raw(lhs)), Val(Raw(rhs))) => Val(Raw(lhs + rhs)),
                (_, Val(Raw(rhs))) => Add(*v1, Raw(rhs)),
                (Val(Raw(lhs)), _) => Add(Raw(lhs), *v2),
                (_, _) => *self,
            },
            Sub(v1, v2) => match (v1.partial_eval(env), v2.partial_eval(env)) {
                (Val(Raw(lhs)), Val(Raw(rhs))) => Val(Raw(lhs - rhs)),
                (_, Val(Raw(rhs))) => Sub(*v1, Raw(rhs)),
                (Val(Raw(lhs)), _) => Sub(Raw(lhs), *v2),
                (_, _) => *self,
            },
            Mul(v1, v2) => match (v1.partial_eval(env), v2.partial_eval(env)) {
                (Val(Raw(lhs)), Val(Raw(rhs))) => Val(Raw(lhs * rhs)),
                (_, Val(Raw(rhs))) => Mul(*v1, Raw(rhs)),
                (Val(Raw(lhs)), _) => Mul(Raw(lhs), *v2),
                (_, _) => *self,
            },
            Div(v1, v2) => match (v1.partial_eval(env), v2.partial_eval(env)) {
                (Val(Raw(lhs)), Val(Raw(rhs))) => Val(Raw(lhs / rhs)),
                (_, Val(Raw(rhs))) => Div(*v1, Raw(rhs)),
                (Val(Raw(lhs)), _) => Div(Raw(lhs), *v2),
                (_, _) => *self,
            },
            // Obviously, a value has fewer options
            Expression::Val(value) => value.partial_eval(env),
        }
    }
}

```

Lots of `match` statements in that, but it all boils down to relatively simple math. I won’t reveal how long it took me to _realize_ it was relatively simple math, but once I got that part, the rest sort of fell into place.

## Wrap Up

Today was an _incredibly_ fun puzzle. I really enjoyed working out how to represent today’s problem space. The recursive evaluation for part one was really straightforward, and so was the step-wise “solve for x” approach to part two once I realized that that would work. I suspect this was actually the intended solution for today, because once you realize it, it’s just so “obvious” that it should work this way. Implementing it in code brought a whole host of considerations, but in the end, it was figuring out how to translate a logical, understandable process into code. Something about that just scratches an itch for me, and I honestly found today’s puzzle to be pretty calming, overall.