Day 21 part 2

1 files changed, 38 insertions, 31 deletions

diff --git a/2022/src/bin/day_21.rs b/2022/src/bin/day_21.rs
index 7b23bab..d118826 100644
--- a/2022/src/bin/day_21.rs
+++ b/2022/src/bin/day_21.rs
@@ -9,7 +9,7 @@ use nom::{
 };
 use std::{
     collections::{BTreeMap, BTreeSet},
-    fmt, fs,
+    fs,
 };
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -29,14 +29,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         .0
         .insert("humn".into(), Expression::Value(Value::Input));
 
-    // TODO: This should be some sort of loop until done. It isn't complete yet.
-    monkeys.simplify();
-    dbg!(monkeys.0.len());
-    monkeys.simplify();
-    dbg!(monkeys.0.len());
-    monkeys.simplify();
-    dbg!(monkeys.0.len());
-    dbg!(monkeys.print_expression("root"));
+    while monkeys.0.len() > 1 {
+        monkeys.simplify();
+    }
+    println!("{}", monkeys.print_expression("root"));
 
     Ok(())
 }
@@ -119,7 +115,6 @@ impl Monkeys {
         }
 
         // simplify across the equals
-        // TODO: There are probably more of these cases needed
         for id in &ids {
             let monkey = self.0.get(id).expect("Unknown monkey!").clone();
             match monkey {
@@ -128,28 +123,29 @@ impl Monkeys {
                     let referenced_monkey = self.0.get(&r).expect("Unknown monkey!").clone();
 
                     let new_eql = match referenced_monkey {
-                        Expression::Add(Value::Ref(new_r), Value::Literal(added))
-                        | Expression::Add(Value::Literal(added), Value::Ref(new_r)) => {
-                            Some((new_r.clone(), v - added))
+                        Expression::Add(new_lhs, Value::Literal(added))
+                        | Expression::Add(Value::Literal(added), new_lhs) => {
+                            Some((new_lhs.clone(), v - added))
+                        }
+                        Expression::Sub(new_lhs, Value::Literal(subtracted)) => {
+                            Some((new_lhs.clone(), v + subtracted))
                         }
-                        Expression::Sub(Value::Ref(new_r), Value::Literal(subtracted)) => {
-                            Some((new_r.clone(), v + subtracted))
+                        Expression::Sub(Value::Literal(subtracted_from), new_lhs) => {
+                            Some((new_lhs.clone(), subtracted_from - v))
                         }
-                        Expression::Mul(Value::Ref(new_r), Value::Literal(mult))
-                        | Expression::Mul(Value::Literal(mult), Value::Ref(new_r)) => {
-                            Some((new_r.clone(), v / mult))
+                        Expression::Mul(new_lhs, Value::Literal(mult))
+                        | Expression::Mul(Value::Literal(mult), new_lhs) => {
+                            Some((new_lhs.clone(), v / mult))
                         }
-                        Expression::Div(Value::Ref(new_r), Value::Literal(denom)) => {
-                            Some((new_r.clone(), v * denom))
+                        Expression::Div(new_lhs, Value::Literal(denom)) => {
+                            Some((new_lhs.clone(), v * denom))
                         }
                         _ => None,
                     };
 
-                    if let Some((new_r, new_v)) = new_eql {
-                        self.0.insert(
-                            id.clone(),
-                            Expression::Eql(Value::Ref(new_r), Value::Literal(new_v)),
-                        );
+                    if let Some((new_lhs, new_v)) = new_eql {
+                        self.0
+                            .insert(id.clone(), Expression::Eql(new_lhs, Value::Literal(new_v)));
                     }
                 }
                 _ => {}
@@ -225,14 +221,25 @@ impl Monkeys {
     fn print_expression(&self, id: &str) -> String {
         let monkey = self.0.get(id).expect("Unknown monkey!");
 
+        // The crazy newlines here make it easier to see the
+        // brackets. Drop it in emacs and autoindent, and it's easy to
+        // see the next expression which isn't being collapsed.
         match monkey {
-            Expression::Value(v) => format!("({})", self.print_value(v)),
-            Expression::Add(a, b) => format!("({} + {})", self.print_value(a), self.print_value(b)),
-            Expression::Sub(a, b) => format!("({} - {})", self.print_value(a), self.print_value(b)),
-            Expression::Mul(a, b) => format!("({} * {})", self.print_value(a), self.print_value(b)),
-            Expression::Div(a, b) => format!("({} / {})", self.print_value(a), self.print_value(b)),
+            Expression::Value(v) => format!("(\n{}\n)", self.print_value(v)),
+            Expression::Add(a, b) => {
+                format!("(\n{}\n+\n{}\n)", self.print_value(a), self.print_value(b))
+            }
+            Expression::Sub(a, b) => {
+                format!("(\n{}\n-\n{}\n)", self.print_value(a), self.print_value(b))
+            }
+            Expression::Mul(a, b) => {
+                format!("(\n{}\n*\n{}\n)", self.print_value(a), self.print_value(b))
+            }
+            Expression::Div(a, b) => {
+                format!("(\n{}\n/\n{}\n)", self.print_value(a), self.print_value(b))
+            }
             Expression::Eql(a, b) => {
-                format!("({} == {})", self.print_value(a), self.print_value(b))
+                format!("(\n{}\n=\n{}\n)", self.print_value(a), self.print_value(b))
             }
         }
     }