puzzle(2024): Day 2

README.md

@@ -37,6 +37,11 @@ SKIP_SLOW_TESTS=1 bundle exec rake test
       <td><a href="lib/puzzles/2024/day01"><code>lib/puzzles/2024/day01</code></a></td>
       <td>🌟🌟</td>
     </tr>
+    <tr>
+      <td>2️⃣ <a href="https://adventofcode.com/2024/day/2">Red-Nosed Reports</a></td>
+      <td><a href="lib/puzzles/2024/day02"><code>lib/puzzles/2024/day01</code></a></td>
+      <td>🌟🌟</td>
+    </tr>
   </table>
 </details>
 

lib/puzzles/2023/day12/README.md

@@ -0,0 +1,80 @@
+# [Day 12: Hot Springs](https://adventofcode.com/2023/day/12)
+
+You finally reach the hot springs! You can see steam rising from secluded areas attached to the primary, ornate building.
+
+As you turn to enter, the [researcher](https://adventofcode.com/2023/day/11) stops you. "Wait - I thought you were looking for the hot springs, weren't you?" You indicate that this definitely looks like hot springs to you.
+
+"Oh, sorry, common mistake! This is actually the [onsen](https://en.wikipedia.org/wiki/Onsen)! The hot springs are next door."
+
+You look in the direction the researcher is pointing and suddenly notice the massive metal helixes towering overhead. "This way!"
+
+It only takes you a few more steps to reach the main gate of the massive fenced-off area containing the springs. You go through the gate and into a small administrative building.
+
+"Hello! What brings you to the hot springs today? Sorry they're not very hot right now; we're having a **lava shortage** at the moment." You ask about the missing machine parts for Desert Island.
+
+"Oh, all of Gear Island is currently offline! Nothing is being manufactured at the moment, not until we get more lava to heat our forges. And our springs. The springs aren't very springy unless they're hot!"
+
+"Say, could you go up and see why the lava stopped flowing? The springs are too cold for normal operation, but we should be able to find one springy enough to launch **you** up there!"
+
+There's just one problem - many of the springs have fallen into disrepair, so they're not actually sure which springs would even be **safe** to use! Worse yet, their **condition records of which springs are damaged** (your puzzle input) are also damaged! You'll need to help them repair the damaged records.
+
+In the giant field just outside, the springs are arranged into **rows**. For each row, the condition records show every spring and whether it is **operational** (`.`) or **damaged** (`#`). This is the part of the condition records that is itself damaged; for some springs, it is simply **unknown** (`?`) whether the spring is operational or damaged.
+
+However, the engineer that produced the condition records also duplicated some of this information in a different format! After the list of springs for a given row, the size of each **contiguous group of damaged springs** is listed in the order those groups appear in the row. This list always accounts for every damaged spring, and each number is the entire size of its contiguous group (that is, groups are always separated by at least one operational spring: `####` would always be `4`, never `2,2`).
+
+So, condition records with no unknown spring conditions might look like this:
+
+```
+#.#.### 1,1,3
+.#...#....###. 1,1,3
+.#.###.#.###### 1,3,1,6
+####.#...#... 4,1,1
+#....######..#####. 1,6,5
+.###.##....# 3,2,1
+```
+
+However, the condition records are partially damaged; some of the springs' conditions are actually **unknown** (`?`). For example:
+
+```
+???.### 1,1,3
+.??..??...?##. 1,1,3
+?#?#?#?#?#?#?#? 1,3,1,6
+????.#...#... 4,1,1
+????.######..#####. 1,6,5
+?###???????? 3,2,1
+```
+
+Equipped with this information, it is your job to figure out **how many different arrangements** of operational and broken springs fit the given criteria in each row.
+
+In the first line (`???.### 1,1,3`), there is exactly **one** way separate groups of one, one, and three broken springs (in that order) can appear in that row: the first three unknown springs must be broken, then operational, then broken (`#.#`), making the whole row `#.#.###`.
+
+The second line is more interesting: `.??..??...?##. 1,1,3` could be a total of **four** different arrangements. The last `?` must always be broken (to satisfy the final contiguous group of three broken springs), and each `??` must hide exactly one of the two broken springs. (Neither `??` could be both broken springs or they would form a single contiguous group of two; if that were true, the numbers afterward would have been `2,3` instead.) Since each `??` can either be `#.` or `.#`, there are four possible arrangements of springs.
+
+The last line is actually consistent with **ten** different arrangements! Because the first number is `3`, the first and second `?` must both be `.` (if either were `#`, the first number would have to be `4` or higher). However, the remaining run of unknown spring conditions have many different ways they could hold groups of two and one broken springs:
+
+```
+?###???????? 3,2,1
+.###.##.#...
+.###.##..#..
+.###.##...#.
+.###.##....#
+.###..##.#..
+.###..##..#.
+.###..##...#
+.###...##.#.
+.###...##..#
+.###....##.#
+```
+
+In this example, the number of possible arrangements for each row is:
+
+- `???.### 1,1,3` - **`1`** arrangement
+- `.??..??...?##. 1,1,3` - **`4`** arrangements
+- `?#?#?#?#?#?#?#? 1,3,1,6` - **`1`** arrangement
+- `????.#...#... 4,1,1` - **`1`** arrangement
+- `????.######..#####. 1,6,5` - **`4`** arrangements
+- `?###???????? 3,2,1` - **`10`** arrangements
+
+Adding all of the possible arrangement counts together produces a total of **`21`** arrangements.
+
+For each row, count all of the different arrangements of operational and broken springs that meet the given criteria. **What is the sum of those counts?**

lib/puzzles/2023/day12/day12.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module AdventOfCode
+  module Puzzles2023
+    ##
+    # {include:file:lib/puzzles/2023/day12/README.md}
+    module Day12
+    end
+  end
+end

lib/puzzles/2024/day01/part1.rb

@@ -4,7 +4,7 @@ module AdventOfCode
   module Puzzles2024
     module Day01
       ##
-      # Class for solving Day 1 - Part 1 puzzle
+      # Class for solving Day 1 (2024) - Part 1 puzzle
       class Part1
         ##
         # @param file [String|nil] file with puzzle input

lib/puzzles/2024/day01/part2.rb

@@ -6,7 +6,7 @@ module AdventOfCode
   module Puzzles2024
     module Day01
       ##
-      # Class for solving Day 1 - Part 2 puzzle
+      # Class for solving Day 1 (2024) - Part 2 puzzle
       class Part2 < Part1
         ##
         # Compute the answer for the puzzle.

lib/puzzles/2024/day02/README.md

@@ -0,0 +1,69 @@
+# [Day 2: Red-Nosed Reports](https://adventofcode.com/2024/day/2)
+
+## Part One
+
+Fortunately, the first location The Historians want to search isn't a long walk from the Chief Historian's office.
+
+While the [Red-Nosed Reindeer nuclear fusion/fission plant](https://adventofcode.com/2015/day/19) appears to contain no sign of the Chief Historian, the engineers there run up to you as soon as they see you. Apparently, they **still** talk about the time Rudolph was saved through molecular synthesis from a single electron.
+
+They're quick to add that - since you're already here - they'd really appreciate your help analyzing some unusual data from the Red-Nosed reactor. You turn to check if The Historians are waiting for you, but they seem to have already divided into groups that are currently searching every corner of the facility. You offer to help with the unusual data.
+
+The unusual data (your puzzle input) consists of many **reports**, one report per line. Each report is a list of numbers called **levels** that are separated by spaces. For example:
+
+```plaintext
+7 6 4 2 1
+1 2 7 8 9
+9 7 6 2 1
+1 3 2 4 5
+8 6 4 4 1
+1 3 6 7 9
+```
+
+This example data contains six reports each containing five levels.
+
+The engineers are trying to figure out which reports are **safe**. The Red-Nosed reactor safety systems can only tolerate levels that are either gradually increasing or gradually decreasing. So, a report only counts as safe if both of the following are true:
+
+- The levels are either **all increasing** or **all decreasing**.
+- Any two adjacent levels differ by **at least one** and **at most three**.
+
+In the example above, the reports can be found safe or unsafe by checking those rules:
+
+- `7 6 4 2 1`: **`Safe`** because the levels are all decreasing by 1 or 2.
+- `1 2 7 8 9`: **`Unsafe`** because `2 7` is an increase of 5.
+- `9 7 6 2 1`: **`Unsafe`** because `6 2` is a decrease of 4.
+- `1 3 2 4 5`: **`Unsafe`** because `1 3` is increasing but `3 2` is decreasing.
+- `8 6 4 4 1`: **`Unsafe`** because `4 4` is neither an increase or a decrease.
+- `1 3 6 7 9`: **`Safe`** because the levels are all increasing by 1, 2, or 3.
+
+So, in this example, `2` reports are **safe**.
+
+Analyze the unusual data from the engineers. **How many reports are safe?**
+
+Your puzzle answer was `624`.
+
+**The first half of this puzzle is complete! It provides one gold star:** 🌟
+
+## Part Two
+
+The engineers are surprised by the low number of safe reports until they realize they forgot to tell you about the Problem Dampener.
+
+The Problem Dampener is a reactor-mounted module that lets the reactor safety systems **tolerate a single bad level** in what would otherwise be a safe report. It's like the bad level never happened!
+
+Now, the same rules apply as before, except if removing a single level from an unsafe report would make it safe, the report instead counts as safe.
+
+More of the above example's reports are now safe:
+
+- `7 6 4 2 1`: **`Safe`** without removing any level.
+- `1 2 7 8 9`: **`Unsafe`** regardless of which level is removed.
+- `9 7 6 2 1`: **`Unsafe`** regardless of which level is removed.
+- `1 3 2 4 5`: **`Safe`** by removing the second level, `3`.
+- `8 6 4 4 1`: **`Safe`** by removing the third level, `4`.
+- `1 3 6 7 9`: **`Safe`** without removing any level.
+
+Thanks to the Problem Dampener, `4` reports are actually **safe**!
+
+Update your analysis by handling situations where the Problem Dampener can remove a single level from unsafe reports. **How many reports are now safe?**
+
+Your puzzle answer was `658`.
+
+**Both parts of this puzzle are complete! They provide two gold stars:** 🌟🌟

lib/puzzles/2024/day02/day02.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "part1"
+require_relative "part2"
+
+module AdventOfCode
+  module Puzzles2024
+    ##
+    # {include:file:lib/puzzles/2024/day02/README.md}
+    module Day02
+    end
+  end
+end