adventofcode/cc: add solution for 2022/21.

Another fun problem -- I always enjoy tree traversals and simple "interpreter"
problems like this one. The code isn't very pretty, but it works and runs fast
enough.

After some playing around, it turns out that preallocating the right number of
elements in the hash map makes a difference in runtime: preallocation is ~30 %
faster than no preallocation, in my benchmarks.

Benchmarks from `./bazel run -c opt //adventofcode/cc/year2022:day24_benchmark`:

    === With preallocation ===
    2023-06-17T20:56:59+01:00
    Running /home/saser/.cache/bazel/_bazel_saser/06ad534583e887506ca6aa175f8ed7b5/execroot/code/bazel-out/k8-opt/bin/adventofcode/cc/year2022/day21_benchmark
    Run on (16 X 4679.3 MHz CPU s)
    CPU Caches:
    L1 Data 32 KiB (x16)
    L1 Instruction 32 KiB (x8)
    L2 Unified 512 KiB (x8)
    L3 Unified 16384 KiB (x1)
    Load Average: 1.04, 1.10, 0.88
    ***WARNING*** CPU scaling is enabled, the benchmark real time measurements may be noisy and will incur extra overhead.
    -----------------------------------------------------------------
    Benchmark                       Time             CPU   Iterations
    -----------------------------------------------------------------
    BM_Part1/day21.real.in     340559 ns       340553 ns         2058
    BM_Part2/day21.real.in     344647 ns       344638 ns         2033

    === Without preallocation ===
    2023-06-17T20:43:26+01:00
    Running /home/saser/.cache/bazel/_bazel_saser/06ad534583e887506ca6aa175f8ed7b5/execroot/code/bazel-out/k8-opt/bin/adventofcode/cc/year2022/day21_benchmark
    Run on (16 X 4679.3 MHz CPU s)
    CPU Caches:
    L1 Data 32 KiB (x16)
    L1 Instruction 32 KiB (x8)
    L2 Unified 512 KiB (x8)
    L3 Unified 16384 KiB (x1)
    Load Average: 0.55, 0.43, 0.40
    ***WARNING*** CPU scaling is enabled, the benchmark real time measurements may be noisy and will incur extra overhead.
    -----------------------------------------------------------------
    Benchmark                       Time             CPU   Iterations
    -----------------------------------------------------------------
    BM_Part1/day21.real.in     542154 ns       542147 ns         1286
    BM_Part2/day21.real.in     543297 ns       543290 ns         1290

Author: saser

adventofcode/cc/year2022/BUILD.bazel

@@ -743,6 +743,43 @@ cc_aoc_benchmark(
     },
 )
 
+cc_library(
+    name = "day21",
+    srcs = ["day21.cc"],
+    hdrs = ["day21.h"],
+    deps = [
+        "@com_google_absl//absl/container:flat_hash_map",
+        "@com_google_absl//absl/log:check",
+        "@com_google_absl//absl/status",
+        "@com_google_absl//absl/status:statusor",
+        "@com_google_absl//absl/strings",
+    ],
+)
+
+cc_aoc_test(
+    name = "day21_test",
+    library = ":day21",
+    part1 = {
+        "//adventofcode/data/year2022:day21.example.in": "//adventofcode/data/year2022:day21.example.part1.out",
+        "//adventofcode/data/year2022:day21.real.in": "//adventofcode/data/year2022:day21.real.part1.out",
+    },
+    part2 = {
+        "//adventofcode/data/year2022:day21.example.in": "//adventofcode/data/year2022:day21.example.part2.out",
+        "//adventofcode/data/year2022:day21.real.in": "//adventofcode/data/year2022:day21.real.part2.out",
+    },
+)
+
+cc_aoc_benchmark(
+    name = "day21_benchmark",
+    library = ":day21",
+    part1 = {
+        "//adventofcode/data/year2022:day21.real.in": "//adventofcode/data/year2022:day21.real.part1.out",
+    },
+    part2 = {
+        "//adventofcode/data/year2022:day21.real.in": "//adventofcode/data/year2022:day21.real.part2.out",
+    },
+)
+
 cc_library(
     name = "day23",
     srcs = ["day23.cc"],

adventofcode/cc/year2022/day21.cc

@@ -0,0 +1,235 @@
+#include "adventofcode/cc/year2022/day21.h"
+
+#include <cstdint>
+#include <string>
+#include <variant>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/log/check.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/numbers.h"
+#include "absl/strings/str_split.h"
+#include "absl/strings/string_view.h"
+
+namespace adventofcode {
+namespace cc {
+namespace year2022 {
+namespace day21 {
+namespace {
+
+// Monkey represents a single monkey.
+class Monkey {
+ public:
+  // Const represents a constant integer.
+  struct Constant {
+    int64_t v;
+  };
+
+  // Binary represents a binary arithmetic operation.
+  struct Binary {
+    std::string left;
+    char op;
+    std::string right;
+  };
+
+  Monkey() = delete;
+  Monkey(absl::string_view name, int64_t v)
+      : name_(name), expr_(Constant{.v = v}) {}
+  Monkey(absl::string_view name, absl::string_view left, char op,
+         absl::string_view right)
+      : name_(name),
+        expr_(Binary{
+            .left = std::string(left), .op = op, .right = std::string(right)}) {
+  }
+
+  std::variant<Constant, Binary> Expr() const { return expr_; }
+
+  Binary MustBinary() const { return std::get<Binary>(expr_); }
+
+ private:
+  std::string name_;
+
+  // expr_ is either a constant integer or a binary arithmetic expression.
+  std::variant<Constant, Binary> expr_;
+};
+
+absl::flat_hash_map<std::string, Monkey> Parse(absl::string_view input) {
+  std::vector<absl::string_view> lines =
+      absl::StrSplit(input, '\n', absl::SkipEmpty());
+  // By preallocating the right number of elements we appear to save a bunch of
+  // time.
+  absl::flat_hash_map<std::string, Monkey> monkeys(lines.size());
+  for (absl::string_view line : lines) {
+    // This split will result in one of the two following forms:
+    // 1. ["asbo", "12"] in case of a constant.
+    // 2. ["bioa", "bhja", "+", "buyi"] in case of an operation.
+    std::vector<absl::string_view> parts =
+        absl::StrSplit(line, absl::ByAnyChar(": "), absl::SkipEmpty());
+    CHECK(parts.size() == 2 || parts.size() == 4) << line;
+    absl::string_view name = parts[0];
+    switch (parts.size()) {
+      case 2:
+        int64_t v;
+        CHECK(absl::SimpleAtoi(parts[1], &v));
+        monkeys.insert_or_assign(name, Monkey(name, v));
+        break;
+      case 4:
+        monkeys.insert_or_assign(
+            name, Monkey(name, /*left=*/parts[1], /*op=*/parts[2][0],
+                         /*right=*/parts[3]));
+        break;
+    }
+  }
+  return monkeys;
+}
+
+// Value represents what a Monkey evaluates to.
+struct Value {
+  int64_t value;
+  bool has_humn;
+};
+
+void Evaluate(const absl::flat_hash_map<std::string, Monkey>& monkeys,
+              absl::flat_hash_map<std::string, Value>& values,
+              absl::string_view node) {
+  const Monkey& m = monkeys.at(node);
+  Value v;
+  if (std::variant<Monkey::Constant, Monkey::Binary> expr = m.Expr();
+      std::holds_alternative<Monkey::Constant>(expr)) {
+    Monkey::Constant c = std::get<Monkey::Constant>(expr);
+    v.value = c.v;
+    v.has_humn = node == "humn";
+  } else {
+    Monkey::Binary b = std::get<Monkey::Binary>(expr);
+    Evaluate(monkeys, values, b.left);
+    Value left = values.at(b.left);
+    Evaluate(monkeys, values, b.right);
+    Value right = values.at(b.right);
+    switch (b.op) {
+      case '+':
+        v.value = left.value + right.value;
+        break;
+      case '-':
+        v.value = left.value - right.value;
+        break;
+      case '/':
+        v.value = left.value / right.value;
+        break;
+      case '*':
+        v.value = left.value * right.value;
+        break;
+    }
+    v.has_humn = left.has_humn || right.has_humn;
+  }
+  values[node] = v;
+}
+
+absl::flat_hash_map<std::string, Value> Evaluate(
+    const absl::flat_hash_map<std::string, Monkey>& monkeys,
+    absl::string_view node) {
+  // By preallocating the right number of elements we appear to save a bunch of
+  // time.
+  absl::flat_hash_map<std::string, Value> values(monkeys.size());
+  Evaluate(monkeys, values, node);
+  return values;
+}
+
+int64_t FindHumn(const absl::flat_hash_map<std::string, Monkey>& monkeys,
+                 const absl::flat_hash_map<std::string, Value>& values,
+                 absl::string_view node, int64_t target) {
+  if (node == "humn") {
+    return target;
+  }
+  Monkey::Binary b = monkeys.at(node).MustBinary();
+  const Value& left = values.at(b.left);
+  const Value& right = values.at(b.right);
+  std::string next_node = left.has_humn ? b.left : b.right;
+  int64_t next_target = -1;
+  if (left.has_humn) {
+    //                       target = left (humn) <op> right
+    // => target <reverse op> right = left (humn)
+    int64_t r = right.value;
+    switch (b.op) {
+      case '+':
+        next_target = target - r;
+        break;
+      case '-':
+        next_target = target + r;
+        break;
+      case '/':
+        next_target = target * r;
+        break;
+      case '*':
+        next_target = target / r;
+        break;
+    }
+  } else {
+    int64_t l = left.value;
+    switch (b.op) {
+      case '+':
+        //           target = left + right (humn)
+        // => target - left = right (humn)
+        next_target = target - l;
+        break;
+      case '-':
+        //                   target = left - right (humn)
+        // => target + right (humn) = left
+        // =>          right (humn) = left - target
+        next_target = l - target;
+        break;
+      case '/':
+        //                   target = left / right (humn)
+        // => target * right (humn) = left
+        // =>          right (humn) = left / target
+        next_target = l / target;
+        break;
+      case '*':
+        //           target = left * right (humn)
+        // => target / left = right (humn)
+        next_target = target / l;
+        break;
+    }
+  }
+  return FindHumn(monkeys, values, next_node, next_target);
+}
+
+int64_t FindHumn(const absl::flat_hash_map<std::string, Monkey>& monkeys,
+                 const absl::flat_hash_map<std::string, Value>& values) {
+  Monkey::Binary root = monkeys.at("root").MustBinary();
+  const Value& left = values.at(root.left);
+  const Value& right = values.at(root.right);
+  std::string node;
+  int64_t target;
+  if (!left.has_humn) {
+    target = left.value;
+    node = root.right;
+  } else {
+    target = right.value;
+    node = root.left;
+  }
+  return FindHumn(monkeys, values, node, target);
+}
+
+absl::StatusOr<std::string> solve(absl::string_view input, bool part1) {
+  absl::flat_hash_map<std::string, Monkey> monkeys = Parse(input);
+  absl::flat_hash_map<std::string, Value> values = Evaluate(monkeys, "root");
+  if (part1) {
+    return std::to_string(values.at("root").value);
+  }
+  return std::to_string(FindHumn(monkeys, values));
+}
+}  // namespace
+
+absl::StatusOr<std::string> Part1(absl::string_view input) {
+  return solve(input, /*part1=*/true);
+}
+
+absl::StatusOr<std::string> Part2(absl::string_view input) {
+  return solve(input, /*part1=*/false);
+}
+}  // namespace day21
+}  // namespace year2022
+}  // namespace cc
+}  // namespace adventofcode

adventofcode/data/year2022/day21.example.in

@@ -0,0 +1,15 @@
+root: pppw + sjmn
+dbpl: 5
+cczh: sllz + lgvd
+zczc: 2
+ptdq: humn - dvpt
+dvpt: 3
+lfqf: 4
+humn: 5
+ljgn: 2
+sjmn: drzm * dbpl
+sllz: 4
+pppw: cczh / lfqf
+lgvd: ljgn * ptdq
+drzm: hmdt - zczc
+hmdt: 32

adventofcode/data/year2022/day21.example.part1.out

@@ -0,0 +1 @@
+152

adventofcode/data/year2022/day21.example.part2.out

@@ -0,0 +1 @@
+301