aocpp/2024/07.cpp

#include <aocpp/Parsing.hpp>
#include <aocpp/Startup.hpp>

#include <boost/fusion/adapted/std_tuple.hpp>
#include <boost/spirit/include/qi.hpp>

#include <optional>
#include <stack>
#include <tuple>

namespace qi = boost::spirit::qi;

namespace {

auto drop_suffix(std::uint64_t x, std::uint64_t y) -> std::optional<std::uint64_t>
{
  while (x > 0) {
    if (y == 0) { return x; }
    if (x % 10 != y % 10) return std::nullopt;
    x /= 10;
    y /= 10;
  }
  return std::nullopt;
}

auto calibrated(
  bool const part2,
  std::uint64_t const target,
  std::vector<std::uint64_t> const& numbers
) -> bool
{
  if (numbers.size() == 0) { return false; }

  auto work = std::stack<std::tuple<std::size_t, std::uint64_t>>{};
  work.emplace(numbers.size() - 1, target);

  while (not work.empty())
  {
    auto const [i, t] = work.top();
    work.pop();
    auto const x = numbers[i];
    if (i == 0) {
      if (x == t) { return true; }
    } else {
      if (x < t) { work.emplace(i - 1, t - x); }
      if (t % x == 0) { work.emplace(i - 1, t / x); }
      if (part2) {
        if (auto const u = drop_suffix(t, x)) {
          work.emplace(i - 1, *u);
        }
      }
    }
  }

  return false;
}

} // namespace

auto Main(std::istream & in, std::ostream & out) -> void
{
  auto const input = 
    aocpp::ParseSimple
      <std::vector<std::tuple<std::uint64_t, std::vector<std::uint64_t>>>>
      (in, *(qi::ulong_long >> ':' >> +(' ' >> qi::ulong_long) >> '\n'));

  std::uint64_t p1 = 0, p2 = 0;
  for (auto && [x, xs] : input) {
    if (calibrated(false, x, xs)) p1 += x;
    if (calibrated(true,  x, xs)) p2 += x;
  }

  out << "Part 1: " << p1 << "\n"
      << "Part 2: " << p2 << "\n";
}