Day 22 Part 2

Author: monpie3

Day_22/README.md

@@ -14,9 +14,9 @@ The part about secrets is literal, the Historian explains. Each buyer produces a
 
 In particular, each buyer's _secret_ number evolves into the next secret number in the sequence via the following process:
 
-- Calculate the result of _multiplying the secret number by `64`_. Then, _mix_ this result into the secret number. Finally, _prune_ the secret number.
-- Calculate the result of _dividing the secret number by `32`_. Round the result down to the nearest integer. Then, _mix_ this result into the secret number. Finally, _prune_ the secret number.
-- Calculate the result of _multiplying the secret number by `2048`_. Then, _mix_ this result into the secret number. Finally, _prune_ the secret number.
+- Calculate the result of _multiplying the secret number by `64`. Then, _mix_ this result into the secret number. Finally, _prune_ the secret number.
+- Calculate the result of _dividing the secret number by `32`. Round the result down to the nearest integer. Then, _mix_ this result into the secret number. Finally, _prune_ the secret number.
+- Calculate the result of _multiplying the secret number by `2048`. Then, _mix_ this result into the secret number. Finally, _prune_ the secret number.
 
 Each step of the above process involves _mixing_ and _pruning_:
 
@@ -67,3 +67,78 @@ For each buyer, simulate the creation of 2000 new secret numbers. _What is the s
 Your puzzle answer was `[REDACTED]`.
 
 The first half of this puzzle is complete! It provides one gold star: ⭐
+
+
+## \--- Part Two ---
+
+Of course, the secret numbers aren't the prices each buyer is offering! That would be ridiculous. Instead, the _prices_ the buyer offers are just the _ones digit_ of each of their secret numbers.
+
+So, if a buyer starts with a secret number of `123`, that buyer's first ten _prices_ would be:
+
+```
+3 (from 123)
+0 (from 15887950)
+6 (from 16495136)
+5 (etc.)
+4
+4
+6
+4
+4
+2
+```
+
+This price is the number of _bananas_ that buyer is offering in exchange for your information about a new hiding spot. However, you still don't speak [monkey](https://adventofcode.com/2022/day/21), so you can't negotiate with the buyers directly. The Historian speaks a little, but not enough to negotiate; instead, he can ask another monkey to negotiate on your behalf.
+
+Unfortunately, the monkey only knows how to decide when to sell by looking at the _changes_ in price. Specifically, the monkey will only look for a specific sequence of _four consecutive changes_ in price, then immediately sell when it sees that sequence.
+
+So, if a buyer starts with a secret number of `123`, that buyer's first ten secret numbers, prices, and the associated changes would be:
+
+```
+     123: 3
+15887950: 0 (-3)
+16495136: 6 (6)
+  527345: 5 (-1)
+  704524: 4 (-1)
+ 1553684: 4 (0)
+12683156: 6 (2)
+11100544: 4 (-2)
+12249484: 4 (0)
+ 7753432: 2 (-2)
+```
+
+Note that the first price has no associated change because there was no previous price to compare it with.
+
+In this short example, within just these first few prices, the highest price will be `6`, so it would be nice to give the monkey instructions that would make it sell at that time. The first `6` occurs after only two changes, so there's no way to instruct the monkey to sell then, but the second `6` occurs after the changes `-1,-1,0,2`. So, if you gave the monkey that sequence of changes, it would wait until the first time it sees that sequence and then immediately sell your hiding spot information at the current price, winning you `6` bananas.
+
+Each buyer only wants to buy one hiding spot, so after the hiding spot is sold, the monkey will move on to the next buyer. If the monkey _never_ hears that sequence of price changes from a buyer, the monkey will never sell, and will instead just move on to the next buyer.
+
+Worse, you can only give the monkey _a single sequence_ of four price changes to look for. You can't change the sequence between buyers.
+
+You're going to need as many bananas as possible, so you'll need to _determine which sequence_ of four price changes will cause the monkey to get you the _most bananas overall_. Each buyer is going to generate `2000` secret numbers after their initial secret number, so, for each buyer, you'll have `2000` price changes_ in which your sequence can occur.
+
+Suppose the initial secret number of each buyer is:
+
+```
+1
+2
+3
+2024
+```
+
+There are many sequences of four price changes you could tell the monkey, but for these four buyers, the sequence that will get you the most bananas is `-2,1,-1,3`. Using that sequence, the monkey will make the following sales:
+
+- For the buyer with an initial secret number of `1`, changes `-2,1,-1,3` first occur when the price is `7`.
+- For the buyer with initial secret `2`, changes `-2,1,-1,3` first occur when the price is `7`.
+- For the buyer with initial secret `3`, the change sequence `-2,1,-1,3` _does not occur_ in the first 2000 changes.
+- For the buyer starting with `2024`, changes `-2,1,-1,3` first occur when the price is `9`.
+
+So, by asking the monkey to sell the first time each buyer's prices go down `2`, then up `1`, then down `1`, then up `3`, you would get `23` (`7 + 7 + 9`) bananas!
+
+Figure out the best sequence to tell the monkey so that by looking for that same sequence of changes in every buyer's future prices, you get the most bananas in total. _What is the most bananas you can get?_
+
+Your puzzle answer was `1490`.
+
+Your puzzle answer was `[REDACTED]`.
+
+Both parts of this puzzle are complete! They provide two gold stars: ⭐⭐

Day_22/example_22b.txt

@@ -0,0 +1,4 @@
+1
+2
+3
+2024

Day_22/task_22b.py

@@ -0,0 +1,59 @@
+def load_data(filename):
+    with open(filename, "r") as file:
+        return [int(row) for row in file.read().splitlines()]
+
+
+def mix(secret, num):
+    return secret ^ num
+
+
+def prune(secret):
+    return secret % 16777216
+
+
+def generate_new_secret(old_secret, repeat=1):
+    changes = dict()
+    diff = []
+    for _ in range(repeat):
+
+        old_price = int(str(old_secret)[-1])
+        new_secret = prune(mix(old_secret, old_secret * 64))
+        new_secret = prune(mix(new_secret, int(new_secret / 32)))
+        new_secret = prune(mix(new_secret, new_secret * 2048))
+
+        old_secret = new_secret
+
+        new_price = int(str(new_secret)[-1])
+
+        if len(diff) == 4:
+            diff.pop(0)
+
+        diff.append(new_price - old_price)
+
+        if len(diff) == 4:
+            seq = tuple(diff)
+            if seq in changes:
+                continue  # monkey will only buy on the *first* sequence
+            changes[seq] = new_price
+    return new_secret, changes
+
+
+def merge_dicts(merged, dict2):
+    for key, value in dict2.items():
+        if key in merged:
+            merged[key] += value
+        else:
+            merged[key] = value
+
+
+if __name__ == "__main__":
+    data = load_data("Day_22/puzzle_input.txt")
+    repeat = 2000
+
+    merged_changes = dict()
+    for secret in data:
+        new_secret, changes = generate_new_secret(secret, repeat)
+        merge_dicts(merged_changes, changes)
+
+    print(max(merged_changes, key=merged_changes.get))
+    print(max(merged_changes.values()))

Day_22/test_task_22b.py

@@ -0,0 +1,21 @@
+from task_22b import mix, prune, generate_new_secret, merge_dicts, load_data
+
+
+def test_mix():
+    assert mix(42, 15) == 37
+
+
+def test_prune():
+    assert prune(100000000) == 16113920
+
+
+def test_generate_new_secret():
+    repeat = 2000
+    data = load_data("Day_22/example_22b.txt")
+    merged_changes = dict()
+    for secret in data:
+        _, changes = generate_new_secret(secret, repeat)
+        merge_dicts(merged_changes, changes)
+
+    assert max(merged_changes, key=merged_changes.get) == (-2, 1, -1, 3)
+    assert max(merged_changes.values()) == 23