2023-02

2023/02.cpp

@@ -0,0 +1,118 @@
+#include <algorithm>
+#include <cstdint>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <tuple>
+#include <unordered_map>
+#include <vector>
+
+#include <boost/fusion/adapted/std_tuple.hpp>
+#include <boost/phoenix.hpp>
+#include <boost/spirit/include/qi.hpp>
+
+#include <doctest.h>
+
+#include <aocpp/Parsing.hpp>
+#include <aocpp/Startup.hpp>
+
+namespace {
+
+namespace qi = boost::spirit::qi;
+namespace phx = boost::phoenix;
+namespace ascii = boost::spirit::ascii;
+
+struct Game
+{
+    unsigned long long game_id;
+    std::vector<std::vector<std::tuple<unsigned long long, std::string>>> rounds;
+};
+
+struct Grammar : public qi::grammar<std::string::const_iterator, std::vector<Game>(), ascii::space_type> {
+  qi::rule<iterator_type, Game(), ascii::space_type> game;
+  qi::rule<iterator_type, std::vector<Game>(), ascii::space_type> games;
+  qi::rule<iterator_type, std::tuple<unsigned long long, std::string>(), ascii::space_type> entry;
+
+  Grammar() : base_type{games} {
+    using namespace qi::labels;
+    games = *game;
+    game =
+      "Game" >> qi::ulong_long [ phx::bind(&Game::game_id, _val) = _1] >> ":" >>
+      (entry % "," % ";") [ phx::bind(&Game::rounds, _val) = _1];
+    entry = qi::ulong_long >> qi::lexeme [ qi::as_string[+qi::alpha] ];
+  }
+};
+
+auto Part1(std::vector<Game> const& input) -> unsigned long long
+{
+  static auto const limits = std::unordered_map<std::string, unsigned long long>{
+    {"red", 12},
+    {"green", 13},
+    {"blue", 14},
+  };
+
+  unsigned long long result = 0;
+  for (auto const& game : input)
+  {
+    auto const good = std::all_of(game.rounds.begin(), game.rounds.end(), [](auto const& round)
+    {
+      return std::all_of(round.begin(), round.end(), [](auto const& entry)
+      {
+        auto const limit = limits.find(std::get<1>(entry));
+        return limit != limits.end() && limit->second >= std::get<0>(entry);
+      });
+    });
+    if (good)
+    {
+      result += game.game_id;
+    }
+  }
+  return result;
+}
+
+auto Part2(std::vector<Game> const& input) -> unsigned long long
+{
+  unsigned long long result = 0;
+  for (auto const& game : input)
+  {
+    std::unordered_map<std::string, unsigned long long> maxes;
+    for (auto const& round : game.rounds) {
+      for (auto const& [count, color] : round)
+      {
+        auto& entry = maxes[color];
+        entry = std::max(entry, count);
+      }
+    }
+
+    result += std::transform_reduce(
+      maxes.begin(), maxes.end(),
+      1ULL, std::multiplies{}, [](auto& kv) { return kv.second; });
+  }
+
+  return result;
+}
+
+} // namespace
+
+TEST_SUITE("2023-02 examples") {
+  TEST_CASE("example") {
+    std::istringstream in {
+R"(Game 1: 3 blue, 4 red; 1 red, 2 green, 6 blue; 2 green
+Game 2: 1 blue, 2 green; 3 green, 4 blue, 1 red; 1 green, 1 blue
+Game 3: 8 green, 6 blue, 20 red; 5 blue, 4 red, 13 green; 5 green, 1 red
+Game 4: 1 green, 3 red, 6 blue; 3 green, 6 red; 3 green, 15 blue, 14 red
+Game 5: 6 red, 1 blue, 3 green; 2 blue, 1 red, 2 green
+)"
+    };
+    auto const input = aocpp::ParseGrammar_(Grammar{}, in);
+    CHECK(Part1(input) ==     8);
+    CHECK(Part2(input) == 2'286);
+  }
+}
+
+auto Main(std::istream & in, std::ostream & out) -> void
+{
+  auto const input = aocpp::ParseGrammar_(Grammar{}, in);
+  out << "Part 1: " << Part1(input) << std::endl;
+  out << "Part 2: " << Part2(input) << std::endl;
+}

2023/CMakeLists.txt

@@ -0,0 +1,2 @@
+add_executable(2023_02 02.cpp)
+target_link_libraries(2023_02 aocpp Boost::headers)

CMakeLists.txt

@@ -33,3 +33,4 @@ add_subdirectory(2019)
 add_subdirectory(2020)
 add_subdirectory(2021)
 add_subdirectory(2022)
+add_subdirectory(2023)