Line data    Source code

       1              : #include "IntegerCast.h"
       2              : #include "LinewiseInput.h"
       3              : #include "PuzzleImpl.h"
       4              : 
       5              : #include <libassert/assert.hpp>
       6              : 
       7              : #include <algorithm>
       8              : #include <array>
       9              : #include <cstdint>
      10              : #include <numeric>
      11              : #include <string_view>
      12              : 
      13              : namespace {
      14              : 
      15         2500 : uint64_t gameScorePt1(std::string_view const s) {
      16         2500 :   char const opponent = s[0];
      17         2500 :   char const own = s[2];
      18              : 
      19         2500 :   switch (own) {
      20          611 :   case 'X':
      21          611 :     switch (opponent) {
      22          189 :     case 'A':
      23          189 :       return 1u + 3u;
      24           97 :     case 'B':
      25           97 :       return 1u + 0u;
      26          325 :     case 'C':
      27          325 :       return 1u + 6u;
      28            0 :     default:
      29            0 :       UNREACHABLE(opponent);
      30          611 :     }
      31         1524 :   case 'Y':
      32         1524 :     switch (opponent) {
      33         1003 :     case 'A':
      34         1003 :       return 2u + 6u;
      35           56 :     case 'B':
      36           56 :       return 2u + 3u;
      37          465 :     case 'C':
      38          465 :       return 2u + 0u;
      39            0 :     default:
      40            0 :       UNREACHABLE(opponent);
      41         1524 :     }
      42          365 :   case 'Z':
      43          365 :     switch (opponent) {
      44          107 :     case 'A':
      45          107 :       return 3u + 0u;
      46          100 :     case 'B':
      47          100 :       return 3u + 6u;
      48          158 :     case 'C':
      49          158 :       return 3u + 3u;
      50            0 :     default:
      51            0 :       UNREACHABLE(opponent);
      52          365 :     }
      53            0 :   default:
      54            0 :     UNREACHABLE(own);
      55         2500 :   }
      56         2500 : }
      57              : 
      58         2500 : uint64_t gameScorePt2(std::string_view const s) {
      59         2500 :   char const opponent = s[0];
      60         2500 :   char const outcome = s[2];
      61              : 
      62         2500 :   switch (outcome) {
      63          611 :   case 'X':
      64          611 :     switch (opponent) {
      65          189 :     case 'A':
      66          189 :       return 0u + 3u;
      67           97 :     case 'B':
      68           97 :       return 0u + 1u;
      69          325 :     case 'C':
      70          325 :       return 0u + 2u;
      71            0 :     default:
      72            0 :       UNREACHABLE(opponent);
      73          611 :     }
      74         1524 :   case 'Y':
      75         1524 :     switch (opponent) {
      76         1003 :     case 'A':
      77         1003 :       return 3u + 1u;
      78           56 :     case 'B':
      79           56 :       return 3u + 2u;
      80          465 :     case 'C':
      81          465 :       return 3u + 3u;
      82            0 :     default:
      83            0 :       UNREACHABLE(opponent);
      84         1524 :     }
      85          365 :   case 'Z':
      86          365 :     switch (opponent) {
      87          107 :     case 'A':
      88          107 :       return 6u + 2u;
      89          100 :     case 'B':
      90          100 :       return 6u + 3u;
      91          158 :     case 'C':
      92          158 :       return 6u + 1u;
      93            0 :     default:
      94            0 :       UNREACHABLE(opponent);
      95          365 :     }
      96            0 :   default:
      97            0 :     UNREACHABLE(outcome);
      98         2500 :   }
      99         2500 : }
     100              : } // namespace
     101              : 
     102            1 : template <> size_t part1<2022, 2>(std::string_view const input) {
     103            1 :   LinewiseInput const lines(input);
     104              : 
     105            1 :   return std::transform_reduce(lines.begin(), lines.end(), uint64_t(0), std::plus<>(),
     106            1 :                                gameScorePt1);
     107            1 : }
     108              : 
     109            1 : template <> size_t part2<2022, 2>(std::string_view const input) {
     110            1 :   LinewiseInput const lines(input);
     111              : 
     112            1 :   return std::transform_reduce(lines.begin(), lines.end(), uint64_t(0), std::plus<>(),
     113            1 :                                gameScorePt2);
     114            1 : }