docs: add readme files

lauthieb · lauthieb · commit 80635fe9834d · 2024-12-17T00:29:32.000+01:00
diff --git a/day_05/README.md b/day_05/README.md
@@ -84,3 +84,17 @@ These have middle page numbers of `61`, `53`, and `29` respectively. Adding thes
 Of course, you'll need to be careful: the actual list of _page ordering rules_ is bigger and more complicated than the above example.
 
 Determine which updates are already in the correct order. _What do you get if you add up the middle page number from those correctly-ordered updates?_
+
+### Part Two
+
+While the Elves get to work printing the correctly-ordered updates, you have a little time to fix the rest of them.
+
+For each of the _incorrectly-ordered updates_, use the page ordering rules to put the page numbers in the right order. For the above example, here are the three incorrectly-ordered updates and their correct orderings:
+
+*   `75,97,47,61,53` becomes `97,75,47,61,53`.
+*   `61,13,29` becomes `61,29,13`.
+*   `97,13,75,29,47` becomes `97,75,47,29,13`.
+
+After taking _only the incorrectly-ordered updates_ and ordering them correctly, their middle page numbers are `47`, `29`, and `47`. Adding these together produces _`123`_.
+
+Find the updates which are not in the correct order. _What do you get if you add up the middle page numbers after correctly ordering just those updates?_
diff --git a/day_07/README.md b/day_07/README.md
@@ -38,3 +38,19 @@ Only three of the above equations can be made true by inserting operators:
 The engineers just need the _total calibration result_, which is the sum of the test values from just the equations that could possibly be true. In the above example, the sum of the test values for the three equations listed above is _`3749`_.
 
 Determine which equations could possibly be true. _What is their total calibration result?_
+
+### Part Two
+
+The engineers seem concerned; the total calibration result you gave them is nowhere close to being within safety tolerances. Just then, you spot your mistake: some well-hidden elephants are holding a _third type of operator_.
+
+The [concatenation](https://en.wikipedia.org/wiki/Concatenation) operator (`<span title="I think you mean &quot;.&quot;.">||</span>`) combines the digits from its left and right inputs into a single number. For example, `12 || 345` would become `12345`. All operators are still evaluated left-to-right.
+
+Now, apart from the three equations that could be made true using only addition and multiplication, the above example has three more equations that can be made true by inserting operators:
+
+*   `156: 15 6` can be made true through a single concatenation: `15 || 6 = 156`.
+*   `7290: 6 8 6 15` can be made true using `6 * 8 || 6 * 15`.
+*   `192: 17 8 14` can be made true using `17 || 8 + 14`.
+
+Adding up all six test values (the three that could be made before using only `+` and `*` plus the new three that can now be made by also using `||`) produces the new _total calibration result_ of _`11387`_.
+
+Using your new knowledge of elephant hiding spots, determine which equations could possibly be true. _What is their total calibration result?_
diff --git a/day_09/README.md b/day_09/README.md
@@ -58,3 +58,24 @@ The final step of this file-compacting process is to update the _filesystem chec
 Continuing the first example, the first few blocks' position multiplied by its file ID number are `0 * 0 = 0`, `1 * 0 = 0`, `2 * 9 = 18`, `3 * 9 = 27`, `4 * 8 = 32`, and so on. In this example, the checksum is the sum of these, _`1928`_.
 
 <span title="Bonus points if you make a cool animation of this process.">Compact the amphipod's hard drive</span> using the process he requested. _What is the resulting filesystem checksum?_ <span class="quiet">(Be careful copy/pasting the input for this puzzle; it is a single, very long line.)</span>
+
+### Part Two
+
+Upon completion, two things immediately become clear. First, the disk definitely has a lot more contiguous free space, just like the amphipod hoped. Second, the computer is running much more slowly! Maybe introducing all of that [file system fragmentation](https://en.wikipedia.org/wiki/File_system_fragmentation) was a bad idea?
+
+The eager amphipod already has a new plan: rather than move individual blocks, he'd like to try compacting the files on his disk by moving _whole files_ instead.
+
+This time, attempt to move whole files to the leftmost span of free space blocks that could fit the file. Attempt to move each file exactly once in order of _decreasing file ID number_ starting with the file with the highest file ID number. If there is no span of free space to the left of a file that is large enough to fit the file, the file does not move.
+
+The first example from above now proceeds differently:
+
+    00...111...2...333.44.5555.6666.777.888899
+    0099.111...2...333.44.5555.6666.777.8888..
+    0099.1117772...333.44.5555.6666.....8888..
+    0099.111777244.333....5555.6666.....8888..
+    00992111777.44.333....5555.6666.....8888..
+    
+
+The process of updating the filesystem checksum is the same; now, this example's checksum would be _`2858`_.
+
+Start over, now compacting the amphipod's hard drive using this new method instead. _What is the resulting filesystem checksum?_
diff --git a/day_10/README.md b/day_10/README.md
@@ -76,3 +76,66 @@ Here's a larger example:
 This larger example has 9 trailheads. Considering the trailheads in reading order, they have scores of `5`, `6`, `5`, `3`, `1`, `3`, `5`, `3`, and `5`. Adding these scores together, the sum of the scores of all trailheads is _`36`_.
 
 The reindeer gleefully carries over a protractor and adds it to the pile. _What is the sum of the scores of all trailheads on your topographic map?_
+
+### Part Two
+
+The reindeer spends a few minutes reviewing your hiking trail map before realizing something, disappearing for a few minutes, and finally returning with yet another slightly-charred piece of paper.
+
+The paper describes a second way to measure a trailhead called its _rating_. A trailhead's rating is the _number of distinct hiking trails_ which begin at that trailhead. For example:
+
+    .....0.
+    ..4321.
+    ..5..2.
+    ..6543.
+    ..7..4.
+    ..8765.
+    ..9....
+    
+
+The above map has a single trailhead; its rating is `3` because there are exactly three distinct hiking trails which begin at that position:
+
+    .....0.   .....0.   .....0.
+    ..4321.   .....1.   .....1.
+    ..5....   .....2.   .....2.
+    ..6....   ..6543.   .....3.
+    ..7....   ..7....   .....4.
+    ..8....   ..8....   ..8765.
+    ..9....   ..9....   ..9....
+    
+
+Here is a map containing a single trailhead with rating `13`:
+
+    ..90..9
+    ...1.98
+    ...2..7
+    6543456
+    765.987
+    876....
+    987....
+    
+
+This map contains a single trailhead with rating `227` (because there are `121` distinct hiking trails that lead to the `9` on the right edge and `106` that lead to the `9` on the bottom edge):
+
+    012345
+    123456
+    234567
+    345678
+    4.6789
+    56789.
+    
+
+Here's the larger example from before:
+
+    89010123
+    78121874
+    87430965
+    96549874
+    45678903
+    32019012
+    01329801
+    10456732
+    
+
+Considering its trailheads in reading order, they have ratings of `20`, `24`, `10`, `4`, `1`, `4`, `5`, `8`, and `5`. The sum of all trailhead ratings in this larger example topographic map is _`81`_.
+
+You're not sure how, but the reindeer seems to have crafted some tiny flags out of toothpicks and bits of paper and is using them to mark trailheads on your topographic map. _What is the sum of the ratings of all trailheads?_
diff --git a/day_11/README.md b/day_11/README.md
@@ -61,3 +61,9 @@ Here is a longer example:
 In this example, after blinking six times, you would have `22` stones. After blinking 25 times, you would have _`55312`_ stones!
 
 Consider the arrangement of stones in front of you. _How many stones will you have after blinking 25 times?_
+
+### Part Two
+
+The Historians sure are taking a long time. To be fair, the infinite corridors _are_ very large.
+
+_How many stones would you have after blinking a total of 75 times?_
diff --git a/day_12/README.md b/day_12/README.md
@@ -93,3 +93,64 @@ It contains:
 So, it has a total price of _`1930`_.
 
 _What is the total price of fencing all regions on your map?_
+
+### Part Two
+
+Fortunately, the Elves are trying to order so much fence that they qualify for a _bulk discount_!
+
+Under the bulk discount, instead of using the perimeter to calculate the price, you need to use the _number of sides_ each region has. Each straight section of fence counts as a side, regardless of how long it is.
+
+Consider this example again:
+
+    AAAA
+    BBCD
+    BBCC
+    EEEC
+    
+
+The region containing type `A` plants has `4` sides, as does each of the regions containing plants of type `B`, `D`, and `E`. However, the more complex region containing the plants of type `C` has `8` sides!
+
+Using the new method of calculating the per-region price by multiplying the region's area by its number of sides, regions `A` through `E` have prices `16`, `16`, `32`, `4`, and `12`, respectively, for a total price of _`80`_.
+
+The second example above (full of type `X` and `O` plants) would have a total price of _`436`_.
+
+Here's a map that includes an E-shaped region full of type `E` plants:
+
+    EEEEE
+    EXXXX
+    EEEEE
+    EXXXX
+    EEEEE
+    
+
+The E-shaped region has an area of `17` and `12` sides for a price of `204`. Including the two regions full of type `X` plants, this map has a total price of _`236`_.
+
+This map has a total price of _`368`_:
+
+    AAAAAA
+    AAABBA
+    AAABBA
+    ABBAAA
+    ABBAAA
+    AAAAAA
+    
+
+It includes two regions full of type `B` plants (each with `4` sides) and a single region full of type `A` plants (with `4` sides on the outside and `8` more sides on the inside, a total of `12` sides). Be especially careful when counting the fence around regions like the one full of type `A` plants; in particular, each section of fence has an in-side and an out-side, so the fence does not connect across the middle of the region (where the two `B` regions touch diagonally). (The Elves would have used the Möbius Fencing Company instead, but their contract terms were too one-sided.)
+
+The larger example from before now has the following updated prices:
+
+*   A region of `R` plants with price `12 * 10 = 120`.
+*   A region of `I` plants with price `4 * 4 = 16`.
+*   A region of `C` plants with price `14 * 22 = 308`.
+*   A region of `F` plants with price `10 * 12 = 120`.
+*   A region of `V` plants with price `13 * 10 = 130`.
+*   A region of `J` plants with price `11 * 12 = 132`.
+*   A region of `C` plants with price `1 * 4 = 4`.
+*   A region of `E` plants with price `13 * 8 = 104`.
+*   A region of `I` plants with price `14 * 16 = 224`.
+*   A region of `M` plants with price `5 * 6 = 30`.
+*   A region of `S` plants with price `3 * 6 = 18`.
+
+Adding these together produces its new total price of _`1206`_.
+
+_What is the new total price of fencing all regions on your map?_
diff --git a/day_13/README.md b/day_13/README.md
@@ -54,3 +54,30 @@ So, the most prizes you could possibly win is two; the minimum tokens you would
 You estimate that each button would need to be pressed _no more than `100` times_ to win a prize. How else would someone be expected to play?
 
 Figure out how to win as many prizes as possible. _What is the fewest tokens you would have to spend to win all possible prizes?_
+
+### Part Two
+
+As you go to win the first prize, you discover that the claw is nowhere near where you expected it would be. Due to a unit conversion error in your measurements, the position of every prize is actually `10000000000000` higher on both the `X` and `Y` axis!
+
+Add `10000000000000` to the `X` and `Y` position of every prize. After making this change, the example above would now look like this:
+
+    Button A: X+94, Y+34
+    Button B: X+22, Y+67
+    Prize: X=10000000008400, Y=10000000005400
+    
+    Button A: X+26, Y+66
+    Button B: X+67, Y+21
+    Prize: X=10000000012748, Y=10000000012176
+    
+    Button A: X+17, Y+86
+    Button B: X+84, Y+37
+    Prize: X=10000000007870, Y=10000000006450
+    
+    Button A: X+69, Y+23
+    Button B: X+27, Y+71
+    Prize: X=10000000018641, Y=10000000010279
+    
+
+Now, it is only possible to win a prize on the second and fourth claw machines. Unfortunately, it will take _many more than `100` presses_ to do so.
+
+Using the corrected prize coordinates, figure out how to win as many prizes as possible. _What is the fewest tokens you would have to spend to win all possible prizes?_
diff --git a/day_14/README.md b/day_14/README.md
@@ -129,3 +129,9 @@ To determine the safest area, count the _number of robots in each quadrant_ afte
 In this example, the quadrants contain `1`, `3`, `4`, and `1` robot. Multiplying these together gives a total _safety factor_ of _`12`_.
 
 Predict the motion of the robots in your list within a space which is `101` tiles wide and `103` tiles tall. _What will the safety factor be after exactly 100 seconds have elapsed?_
+
+### Part Two
+
+During the bathroom break, someone notices that these robots seem awfully similar to ones built and used at the North Pole. If they're the same type of robots, they should have a hard-coded <span title="This puzzle was originally going to be about the motion of space rocks in a fictitious arcade game called Meteoroids, but we just had an arcade puzzle.">Easter egg</span>: very rarely, most of the robots should arrange themselves into _a picture of a Christmas tree_.
+
+_What is the fewest number of seconds that must elapse for the robots to display the Easter egg?_
diff --git a/day_16/README.md b/day_16/README.md
@@ -96,3 +96,53 @@ In this maze, the best paths cost _`11048`_ points; following one such path woul
 Note that the path shown above includes one 90 degree turn as the very first move, rotating the Reindeer from facing East to facing North.
 
 Analyze your map carefully. _What is the lowest score a Reindeer could possibly get?_
+
+### Part Two
+
+Now that you know what the best paths look like, you can figure out the best spot to sit.
+
+Every non-wall tile (`S`, `.`, or `E`) is equipped with places to sit along the edges of the tile. While determining which of these tiles would be the best spot to sit depends on a whole bunch of factors (how comfortable the seats are, how far away the bathrooms are, whether there's a pillar blocking your view, etc.), the most important factor is _whether the tile is on one of the best paths through the maze_. If you sit somewhere else, you'd miss all the action!
+
+So, you'll need to determine which tiles are part of _any_ best path through the maze, including the `S` and `E` tiles.
+
+In the first example, there are _`45`_ tiles (marked `O`) that are part of at least one of the various best paths through the maze:
+
+    ###############
+    #.......#....O#
+    #.#.###.#.###O#
+    #.....#.#...#O#
+    #.###.#####.#O#
+    #.#.#.......#O#
+    #.#.#####.###O#
+    #..OOOOOOOOO#O#
+    ###O#O#####O#O#
+    #OOO#O....#O#O#
+    #O#O#O###.#O#O#
+    #OOOOO#...#O#O#
+    #O###.#.#.#O#O#
+    #O..#.....#OOO#
+    ###############
+    
+
+In the second example, there are _`64`_ tiles that are part of at least one of the best paths:
+
+    #################
+    #...#...#...#..O#
+    #.#.#.#.#.#.#.#O#
+    #.#.#.#...#...#O#
+    #.#.#.#.###.#.#O#
+    #OOO#.#.#.....#O#
+    #O#O#.#.#.#####O#
+    #O#O..#.#.#OOOOO#
+    #O#O#####.#O###O#
+    #O#O#..OOOOO#OOO#
+    #O#O###O#####O###
+    #O#O#OOO#..OOO#.#
+    #O#O#O#####O###.#
+    #O#O#OOOOOOO..#.#
+    #O#O#O#########.#
+    #O#OOO..........#
+    #################
+    
+
+Analyze your map further. _How many tiles are part of at least one of the best paths through the maze?_
