feat: Day 24: Immune System Simulator 20XX (part 1)

Author: mariotacke

Diff for: .github/badges/completion.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
   "label": "completion",
-  "message": "36/50",
+  "message": "37/50",
   "color": "yellow"
 }

Diff for: README.md

@@ -34,6 +34,7 @@ Collect stars by solving puzzles. Two puzzles will be made available on each day
 - [Day 18: Settlers of The North Pole](day-18-settlers-of-the-north-pole/)
 - [Day 22: Mode Maze](day-22-mode-maze/)
 - [Day 23: Experimental Emergency Teleportation](day-23-experimental-emergency-teleportation/)
+- [Day 24: Immune System Simulator 20XX](day-24-immune-system-simulator-20xx/)
 - [Day 25: Four-Dimensional Adventure](day-25-four-dimensional-adventure/)
 
 ## Running Tests

Diff for: day-24-immune-system-simulator-20xx/README.md

@@ -0,0 +1,191 @@
+## Day 24: Immune System Simulator 20XX
+
+After [a weird buzzing noise](https://www.youtube.com/watch?v=NDVjLt_QHL8&t=7), you appear back at the man's cottage. He seems relieved to see his friend, but quickly notices that the little reindeer caught some kind of cold while out exploring.
+
+The portly man explains that this reindeer's immune system isn't similar to regular reindeer immune systems:
+
+The **immune system** and the **infection** each have an army made up of several **groups**; each **group** consists of one or more identical **units**. The armies repeatedly **fight** until only one army has units remaining.
+
+**Units** within a group all have the same **hit points** (amount of damage a unit can take before it is destroyed), **attack damage** (the amount of damage each unit deals), an **attack type**, an **initiative** (higher initiative units attack first and win ties), and sometimes **weaknesses** or **immunities**. Here is an example group:
+
+```
+18 units each with 729 hit points (weak to fire; immune to cold, slashing)
+ with an attack that does 8 radiation damage at initiative 10
+```
+
+Each group also has an **effective power**: the number of units in that group multiplied by their attack damage. The above group has an effective power of `18 * 8 = 144`. Groups never have zero or negative units; instead, the group is removed from combat.
+
+Each **fight** consists of two phases: **target selection** and **attacking**.
+
+During the **target selection** phase, each group attempts to choose one target. In decreasing order of effective power, groups choose their targets; in a tie, the group with the higher initiative chooses first. The attacking group chooses to target the group in the enemy army to which it would deal the most damage (after accounting for weaknesses and immunities, but not accounting for whether the defending group has enough units to actually receive all of that damage).
+
+If an attacking group is considering two defending groups to which it would deal equal damage, it chooses to target the defending group with the largest effective power; if there is still a tie, it chooses the defending group with the highest initiative. If it cannot deal any defending groups damage, it does not choose a target. Defending groups can only be chosen as a target by one attacking group.
+
+At the end of the target selection phase, each group has selected zero or one groups to attack, and each group is being attacked by zero or one groups.
+
+During the **attacking** phase, each group deals damage to the target it selected, if any. Groups attack in decreasing order of initiative, regardless of whether they are part of the infection or the immune system. (If a group contains no units, it cannot attack.)
+
+The damage an attacking group deals to a defending group depends on the attacking group's attack type and the defending group's immunities and weaknesses. By default, an attacking group would deal damage equal to its **effective power** to the defending group. However, if the defending group is **immune** to the attacking group's attack type, the defending group instead takes **no damage**; if the defending group is **weak** to the attacking group's attack type, the defending group instead takes **double damage**.
+
+The defending group only loses **whole units** from damage; damage is always dealt in such a way that it kills the most units possible, and any remaining damage to a unit that does not immediately kill it is ignored. For example, if a defending group contains **10** units with **10** hit points each and receives **75** damage, it loses exactly **7** units and is left with **3** units at full health.
+
+After the fight is over, if both armies still contain units, a new fight begins; combat only ends once one army has lost all of its units.
+
+For example, consider the following armies:
+
+```
+Immune System:
+17 units each with 5390 hit points (weak to radiation, bludgeoning) with
+ an attack that does 4507 fire damage at initiative 2
+989 units each with 1274 hit points (immune to fire; weak to bludgeoning,
+ slashing) with an attack that does 25 slashing damage at initiative 3
+
+Infection:
+801 units each with 4706 hit points (weak to radiation) with an attack
+ that does 116 bludgeoning damage at initiative 1
+4485 units each with 2961 hit points (immune to radiation; weak to fire,
+ cold) with an attack that does 12 slashing damage at initiative 4
+```
+
+If these armies were to enter combat, the following fights, including details during the target selection and attacking phases, would take place:
+
+```
+Immune System:
+Group 1 contains 17 units
+Group 2 contains 989 units
+Infection:
+Group 1 contains 801 units
+Group 2 contains 4485 units
+
+Infection group 1 would deal defending group 1 185832 damage
+Infection group 1 would deal defending group 2 185832 damage
+Infection group 2 would deal defending group 2 107640 damage
+Immune System group 1 would deal defending group 1 76619 damage
+Immune System group 1 would deal defending group 2 153238 damage
+Immune System group 2 would deal defending group 1 24725 damage
+
+Infection group 2 attacks defending group 2, killing 84 units
+Immune System group 2 attacks defending group 1, killing 4 units
+Immune System group 1 attacks defending group 2, killing 51 units
+Infection group 1 attacks defending group 1, killing 17 units
+```
+
+```
+Immune System:
+Group 2 contains 905 units
+Infection:
+Group 1 contains 797 units
+Group 2 contains 4434 units
+
+Infection group 1 would deal defending group 2 184904 damage
+Immune System group 2 would deal defending group 1 22625 damage
+Immune System group 2 would deal defending group 2 22625 damage
+
+Immune System group 2 attacks defending group 1, killing 4 units
+Infection group 1 attacks defending group 2, killing 144 units
+```
+
+```
+Immune System:
+Group 2 contains 761 units
+Infection:
+Group 1 contains 793 units
+Group 2 contains 4434 units
+
+Infection group 1 would deal defending group 2 183976 damage
+Immune System group 2 would deal defending group 1 19025 damage
+Immune System group 2 would deal defending group 2 19025 damage
+
+Immune System group 2 attacks defending group 1, killing 4 units
+Infection group 1 attacks defending group 2, killing 143 units
+```
+
+```
+Immune System:
+Group 2 contains 618 units
+Infection:
+Group 1 contains 789 units
+Group 2 contains 4434 units
+
+Infection group 1 would deal defending group 2 183048 damage
+Immune System group 2 would deal defending group 1 15450 damage
+Immune System group 2 would deal defending group 2 15450 damage
+
+Immune System group 2 attacks defending group 1, killing 3 units
+Infection group 1 attacks defending group 2, killing 143 units
+```
+
+```
+Immune System:
+Group 2 contains 475 units
+Infection:
+Group 1 contains 786 units
+Group 2 contains 4434 units
+
+Infection group 1 would deal defending group 2 182352 damage
+Immune System group 2 would deal defending group 1 11875 damage
+Immune System group 2 would deal defending group 2 11875 damage
+
+Immune System group 2 attacks defending group 1, killing 2 units
+Infection group 1 attacks defending group 2, killing 142 units
+```
+
+```
+Immune System:
+Group 2 contains 333 units
+Infection:
+Group 1 contains 784 units
+Group 2 contains 4434 units
+
+Infection group 1 would deal defending group 2 181888 damage
+Immune System group 2 would deal defending group 1 8325 damage
+Immune System group 2 would deal defending group 2 8325 damage
+
+Immune System group 2 attacks defending group 1, killing 1 unit
+Infection group 1 attacks defending group 2, killing 142 units
+```
+
+```
+Immune System:
+Group 2 contains 191 units
+Infection:
+Group 1 contains 783 units
+Group 2 contains 4434 units
+
+Infection group 1 would deal defending group 2 181656 damage
+Immune System group 2 would deal defending group 1 4775 damage
+Immune System group 2 would deal defending group 2 4775 damage
+
+Immune System group 2 attacks defending group 1, killing 1 unit
+Infection group 1 attacks defending group 2, killing 142 units
+```
+
+```
+Immune System:
+Group 2 contains 49 units
+Infection:
+Group 1 contains 782 units
+Group 2 contains 4434 units
+
+Infection group 1 would deal defending group 2 181424 damage
+Immune System group 2 would deal defending group 1 1225 damage
+Immune System group 2 would deal defending group 2 1225 damage
+
+Immune System group 2 attacks defending group 1, killing 0 units
+Infection group 1 attacks defending group 2, killing 49 units
+```
+
+```
+Immune System:
+No groups remain.
+Infection:
+Group 1 contains 782 units
+Group 2 contains 4434 units
+```
+
+In the example above, the winning army ends up with `782 + 4434 = 5216 units`.
+
+You scan the reindeer's condition (your puzzle input); the white-bearded man looks nervous. As it stands now, **how many units would the winning army have**?
+
+## References
+- https://adventofcode.com/2018/day/24

Diff for: day-24-immune-system-simulator-20xx/immune-system.js

@@ -0,0 +1,179 @@
+const PRINT_COMBAT_TEXT = false;
+
+function print () {
+  if (PRINT_COMBAT_TEXT) {
+    const args = Array.from(arguments);
+
+    console.log(...args);
+  }
+}
+
+const parseArmyInformation = (input) => {
+  return input
+    .split('\n\n')
+    .map((army, armyIndex) => {
+      const armyName = armyIndex === 0 ? 'Immune System' : 'Infection';
+      const groups = army
+        .split('\n')
+        .slice(1)
+        .map((line, groupIndex) => {
+          const parts = /(\d+) units each with (\d+) hit points .*with an attack that does (\d+) (\w+) damage at initiative (\d+)/.exec(line.trim());
+          const modifiers = /\((.*)\)/.exec(line.trim());
+
+          const tags = modifiers
+            ? modifiers[1].split(';').reduce((map, definition) => {
+              /weak to/.test(definition)
+                ? map.set('weaknesses', new Set(/weak to (.*)/.exec(definition)[1].split(', ')))
+                : map.set('immunities', new Set(/immune to (.*)/.exec(definition)[1].split(', ')));
+
+              return map;
+            }, new Map())
+            : new Map();
+
+          return {
+            armyName,
+            number: groupIndex + 1,
+            units: +parts[1],
+            hitPoints: +parts[2],
+            weaknesses: tags.get('weaknesses') || new Set(),
+            immunities: tags.get('immunities') || new Set(),
+            attackDamage: +parts[3],
+            attackType: parts[4],
+            initiative: +parts[5],
+            get effectivePower() {
+              return this.units * this.attackDamage;
+            },
+            get isDead() {
+              return this.units <= 0;
+            },
+          };
+        });
+
+      return {
+        name: armyName,
+        groups,
+        get isDead() {
+          return this.groups.every((group) => group.isDead);
+        },
+      };
+    });
+};
+
+const printArmyStatus = (army) => {
+  print(`${army.name}:`);
+  army.groups.every((group) => group.isDead)
+    ? print('No groups remain.')
+    : army.groups.forEach((group) => !group.isDead && print(`Group ${group.number} contains ${group.units} units`));
+};
+
+const attackerSelectionSort = (a, b) => {
+  return b.effectivePower - a.effectivePower === 0
+    ? b.initiative - a.initiative
+    : b.effectivePower - a.effectivePower;
+};
+
+const effectiveDamage = (attacker, defender) => {
+  const { effectivePower, attackType } = attacker;
+
+  return (defender.weaknesses.has(attackType) ? 2 : (defender.immunities.has(attackType) ? 0 : 1)) * effectivePower;
+};
+
+const targetSelectionSort = (a, b) => {
+  return b.damage - a.damage === 0
+    ? b.group.effectivePower - a.group.effectivePower === 0
+      ? b.group.initiative - a.group.initiative
+      : b.group.effectivePower - a.group.effectivePower
+    : b.damage - a.damage;
+};
+
+const targetSelectionPhase = (attackers, defenders) => {
+  const sortedAttackers = [...attackers.groups].filter((group) => !group.isDead).sort(attackerSelectionSort);
+  const availableDefenders = [...defenders.groups].filter((group) => !group.isDead);
+  const plannedAttacks = [];
+
+  sortedAttackers.forEach((attackingGroup) => {
+    const effectiveDamageOnDefenders = availableDefenders.map((defendingGroup) => {
+      return {
+        damage: effectiveDamage(attackingGroup, defendingGroup),
+        group: defendingGroup,
+      };
+    });
+
+    // print target selection phase
+    effectiveDamageOnDefenders.forEach(({ damage, group }) => {
+      print(`${attackers.name} group ${attackingGroup.number} would deal defending group ${group.number} ${damage} damage`);
+    });
+
+    if (!effectiveDamageOnDefenders.length) {
+      return;
+    }
+
+    const selectedTarget = effectiveDamageOnDefenders.sort(targetSelectionSort)[0];
+
+    if (selectedTarget.damage === 0) {
+      return;
+    }
+
+    plannedAttacks.push({
+      attackingGroup,
+      defendingGroup: selectedTarget.group,
+    });
+
+    const selectedDefenderIndex = availableDefenders.findIndex(({ number }) => selectedTarget.group.number === number);
+
+    availableDefenders.splice(selectedDefenderIndex, 1);
+  });
+
+  return plannedAttacks;
+};
+
+const attackingPhaseSort = (a, b) => {
+  return b.attackingGroup.initiative - a.attackingGroup.initiative;
+};
+
+const attackingPhase = (plannedAttacks) => {
+  const sortedAttackingOrder = plannedAttacks.sort(attackingPhaseSort);
+
+  for (let i = 0; i < sortedAttackingOrder.length; i++) {
+    const { attackingGroup, defendingGroup } = sortedAttackingOrder[i];
+    const damage = effectiveDamage(attackingGroup, defendingGroup);
+    const killedUnits = Math.min(Math.floor(damage / defendingGroup.hitPoints), defendingGroup.units);
+
+    print(`${attackingGroup.armyName} group ${attackingGroup.number} attacks defending group ${defendingGroup.number}, killing ${killedUnits} units`);
+
+    defendingGroup.units -= killedUnits;
+  }
+};
+
+module.exports = (input) => {
+  const armies = parseArmyInformation(input);
+
+  while (!armies[0].isDead && !armies[1].isDead) {
+    printArmyStatus(armies[0]);
+    printArmyStatus(armies[1]);
+
+    print('');
+
+    // target selection phase
+    const plannedAttacks = [
+      ...targetSelectionPhase(armies[1], armies[0]),
+      ...targetSelectionPhase(armies[0], armies[1]),
+    ];
+
+    print('');
+
+    // attacking phase
+    attackingPhase(plannedAttacks);
+
+    print('');
+  }
+
+  printArmyStatus(armies[0]);
+  printArmyStatus(armies[1]);
+
+  return armies
+    .find((army) => !army.isDead).groups
+    .reduce((units, group) => units + group.units, 0);
+};
+
+// 18341 too high