Add solution for 2015 Day 22

res/2015/day22/test_input.txt

@@ -0,0 +1,2 @@
+Hit Points: 13
+Damage: 8

src/2015/Day21.cpp

@@ -2,30 +2,117 @@
 
 namespace y2015::day21
 {
-  REGISTER_DAY(2015, Day21, std::vector<int>, int);
+  struct Entity
+  {
+    int hp;
+    int dmg;
+    int armor;
+  };
 
-  REGISTER_TEST_EXAMPLE(2015, Day21, ExampleInput, 1, 0);
+  struct Item
-  REGISTER_TEST(2015, Day21, Input, 1, 0);
+  {
-  REGISTER_TEST_EXAMPLE(2015, Day21, ExampleInput, 2, 0);
+    int cost;
-  REGISTER_TEST(2015, Day21, Input, 2, 0);
+    int dmg;
+    int armor;
+  };
+
+  REGISTER_DAY(2015, Day21, Entity, int);
+
+  REGISTER_TEST(2015, Day21, Input, 1, 91);
+  REGISTER_TEST(2015, Day21, Input, 2, 158);
 
   READ_INPUT(input)
   {
-    std::vector<int> vec;
+    Entity monster;
-    std::string str;
+    input >> "Hit Points: " >> monster.hp >> "\n";
-    while (getline(input, str))
+    input >> "Damage: " >> monster.dmg >> "\n";
-    {
+    input >> "Armor: " >> monster.armor >> "\n";
-    }
+    return monster;
-    return vec;
   }
 
+  bool Win(Entity player, Entity monster)
+  {
+    int playerDmgPerRound = std::max(1, (player.dmg - monster.armor));
+    int monsterDmgPerRound = std::max(1, (monster.dmg - player.armor));
+
+    int i = 0;
+    while (true)
+    {
+      if (i % 2 == 0)
+      {
+        monster.hp -= playerDmgPerRound;
+        if (monster.hp <= 0)
+          return true;
+      }
+      else
+      {
+        player.hp -= monsterDmgPerRound;
+        if (player.hp <= 0)
+          return false;
+      }
+      i++;
+    }
+  }
+
+  std::vector<Item> weapons{Item{8, 4, 0}, Item{10, 5, 0}, Item{25, 6, 0}, Item{40, 7, 0}, Item{74, 8, 0}};
+  std::vector<Item> armors{
+    Item{13, 0, 1}, Item{31, 0, 2}, Item{53, 0, 3}, Item{75, 0, 4}, Item{102, 0, 5}, Item{0, 0, 0}};
+  std::vector<Item> rings{Item{25, 0, 1},
+                          Item{50, 0, 2},
+                          Item{100, 0, 3},
+                          Item{20, 0, 1},
+                          Item{40, 0, 2},
+                          Item{80, 0, 3},
+                          Item{0, 0, 0},
+                          Item{0, 0, 0}};
+
   OUTPUT1(input)
   {
-    return 0;
+    int minCost = std::numeric_limits<int>::max();
+    for (auto& weapon : weapons)
+    {
+      for (auto& armor : armors)
+      {
+        for (int i = 0; i < rings.size(); i++)
+        {
+          for (int j = i + 1; j < rings.size(); j++)
+          {
+            int cost = weapon.cost + armor.cost + rings[i].cost + rings[j].cost;
+            int dmgStat = weapon.dmg + armor.dmg + rings[i].dmg + rings[j].dmg;
+            int armorStat = weapon.armor + armor.armor + rings[i].armor + rings[j].armor;
+            if (cost > minCost)
+              continue;
+            if (Win(Entity{100, dmgStat, armorStat}, input))
+              minCost = cost;
+          }
+        }
+      }
+    }
+    return minCost;
   }
 
   OUTPUT2(input)
   {
-    return 0;
+    int maxCost = 0;
+    for (auto& weapon : weapons)
+    {
+      for (auto& armor : armors)
+      {
+        for (int i = 0; i < rings.size(); i++)
+        {
+          for (int j = i + 1; j < rings.size(); j++)
+          {
+            int cost = weapon.cost + armor.cost + rings[i].cost + rings[j].cost;
+            int dmgStat = weapon.dmg + armor.dmg + rings[i].dmg + rings[j].dmg;
+            int armorStat = weapon.armor + armor.armor + rings[i].armor + rings[j].armor;
+            if (cost < maxCost)
+              continue;
+            if (!Win(Entity{100, dmgStat, armorStat}, input))
+              maxCost = cost;
+          }
+        }
+      }
+    }
+    return maxCost;
   }
 }

src/2015/Day22.cpp

@@ -2,30 +2,163 @@
 
 namespace y2015::day22
 {
-  REGISTER_DAY(2015, Day22, std::vector<int>, int);
+  struct Player
+  {
+    int hp;
+    int armor;
+    int mana;
+  };
 
-  REGISTER_TEST_EXAMPLE(2015, Day22, ExampleInput, 1, 0);
+  struct Monster
-  REGISTER_TEST(2015, Day22, Input, 1, 0);
+  {
-  REGISTER_TEST_EXAMPLE(2015, Day22, ExampleInput, 2, 0);
+    int hp;
-  REGISTER_TEST(2015, Day22, Input, 2, 0);
+    int dmg;
+  };
+
+  REGISTER_DAY(2015, Day22, Monster, int);
+
+  REGISTER_TEST_EXAMPLE(2015, Day22, ExampleInput, 1, 212);
+  REGISTER_TEST(2015, Day22, Input, 1, 900);
+  REGISTER_TEST_EXAMPLE(2015, Day22, ExampleInput, 2, 212);
+  REGISTER_TEST(2015, Day22, Input, 2, 1216);
 
   READ_INPUT(input)
   {
-    std::vector<int> vec;
+    Monster monster;
-    std::string str;
+    input >> "Hit Points: " >> monster.hp >> "\n";
-    while (getline(input, str))
+    input >> "Damage: " >> monster.dmg >> "\n";
+    return monster;
+  }
+
+  struct Spell
+  {
+    int cost;
+    int timer;
+    int dmg;
+    int armor;
+    int manaGain;
+    int heal;
+  };
+
+  struct State
+  {
+    Player player;
+    Monster monster;
+    std::vector<int> spellTimers;
+
+    bool operator<(const State& other) const
     {
+      if (player.hp != other.player.hp)
+        return player.hp < other.player.hp;
+      if (player.armor != other.player.armor)
+        return player.armor < other.player.armor;
+      if (player.mana != other.player.mana)
+        return player.mana < other.player.mana;
+
+      if (monster.hp != other.monster.hp)
+        return monster.hp < other.monster.hp;
+      if (monster.dmg != other.monster.dmg)
+        return monster.dmg < other.monster.dmg;
+
+      return spellTimers < other.spellTimers;
     }
-    return vec;
+  };
+
+  // clang-format off
+  //                                    cost  timer  dmg  armor  manaGain  heal
+  const std::vector<Spell> spells{Spell{53,   1,     4,   0,     0,        0},
+                                  Spell{73,   1,     2,   0,     0,        2},
+                                  Spell{113,  6,     0,   7,     0,        0},
+                                  Spell{173,  6,     3,   0,     0,        0},
+                                  Spell{229,  5,     0,   0,     101,      0}};
+  // clang-format-on
+
+  void ApplyEffects(State& state)
+  {
+    for (int i = 0; i < state.spellTimers.size(); i++)
+    {
+      if (state.spellTimers[i] == 0)
+        continue;
+
+      const auto& spell = spells[i];
+      state.spellTimers[i]--;
+      state.monster.hp -= spell.dmg;
+      state.player.hp += spell.heal;
+      state.player.mana += spell.manaGain;
+      if (state.spellTimers[i] == 0)
+        state.player.armor -= spell.armor;
+    }
+  }
+
+  std::pair<bool, int> PlayerTurn(State state, bool hardmode, std::map<State, std::pair<bool, int>>& memoization)
+  {
+    // Apply rules at start of turn
+    if (hardmode)
+      state.player.hp--;
+    if (state.player.hp <= 0)
+      return {false, 0};
+    ApplyEffects(state);
+
+    if (state.monster.hp <= 0)
+      return {true, 0};
+
+    auto it = memoization.find(state);
+    if (it != memoization.end())
+      return it->second;
+
+    bool canWin = false;
+    int minManaCost = std::numeric_limits<int>::max();
+    for (int i = 0; i < spells.size(); i++)
+    {
+      // Spell is already active
+      if (state.spellTimers[i] > 0)
+        continue;
+
+      const auto& spell = spells[i];
+      if (state.player.mana < spell.cost)
+        continue;
+
+      // Cast spell
+      State newState = state;
+      newState.spellTimers[i] = spell.timer;
+      newState.player.mana -= spell.cost;
+      newState.player.armor += spell.armor;
+
+      // Boss turn
+      ApplyEffects(newState);
+      if (newState.monster.hp <= 0)
+      {
+        if (spell.cost < minManaCost)
+        {
+          minManaCost = spell.cost;
+          canWin = true;
+        }
+        continue;
+      }
+      newState.player.hp -= std::max(1, newState.monster.dmg - newState.player.armor);
+
+      // Player turn
+      auto result = PlayerTurn(newState, hardmode, memoization);
+      if (result.first && result.second + spell.cost < minManaCost)
+      {
+        canWin = true;
+        minManaCost = result.second + spell.cost;
+      }
+    }
+
+    memoization[state] = {canWin, minManaCost};
+    return {canWin, minManaCost};
   }
 
   OUTPUT1(input)
   {
-    return 0;
+    std::map<State, std::pair<bool, int>> memoization;
+    return PlayerTurn(State{Player{50, 0, 500}, input, {0, 0, 0, 0, 0}}, false, memoization).second;
   }
 
   OUTPUT2(input)
   {
-    return 0;
+    std::map<State, std::pair<bool, int>> memoization;
+    return PlayerTurn(State{Player{50, 0, 500}, input, {0, 0, 0, 0, 0}}, true, memoization).second;
   }
 }