From 72a2175d099c430bf7940caedb0073fd8713d776 Mon Sep 17 00:00:00 2001 From: FrederikBaerentsen Date: Tue, 26 Nov 2024 19:42:34 +0100 Subject: [PATCH] Added 2017/16 --- 2017/16/16.md | 12 ++++-- 2017/16/solution.py | 25 ++++++++---- 2017/17/17.md | 92 +++++++++++++++++++++++++++++++++++++++++++++ 2017/17/solution.py | 77 +++++++++++++++++++++++++++++++++++++ 2017/18/18.md | 79 ++++++++++++++++++++++++++++++++++++++ 2017/18/solution.py | 42 +++++++++++++++++++++ 6 files changed, 316 insertions(+), 11 deletions(-) create mode 100644 2017/17/17.md create mode 100644 2017/17/solution.py create mode 100644 2017/18/18.md create mode 100644 2017/18/solution.py diff --git a/2017/16/16.md b/2017/16/16.md index 8306abd..9fbea36 100644 --- a/2017/16/16.md +++ b/2017/16/16.md @@ -33,8 +33,6 @@ dance? Your puzzle answer was `ehdpincaogkblmfj`. -The first half of this puzzle is complete! It provides one gold star: \* - ## \-\-- Part Two \-\-- {#part2} Now that you\'re starting to get a feel for the dance moves, you turn @@ -53,7 +51,13 @@ In the example above, their second dance would *begin* with the order *In what order are the programs standing* after their billion dances? -Answer: +Your puzzle answer was `bpcekomfgjdlinha`. -Although it hasn\'t changed, you can still [get your puzzle +Both parts of this puzzle are complete! They provide two gold stars: +\*\* + +At this point, you should [return to your Advent calendar](/2017) and +try another puzzle. + +If you still want to see it, you can [get your puzzle input](16/input). diff --git a/2017/16/solution.py b/2017/16/solution.py index 53a7800..6b71267 100644 --- a/2017/16/solution.py +++ b/2017/16/solution.py @@ -2,6 +2,7 @@ import sys,re,collections from pprint import pprint + sys.path.insert(0, '../../') from fred import list2int @@ -91,6 +92,7 @@ if part == 1: ######################################### if part == 2: + start_value = list('abcdefghijklmnop') with open(input_f) as file: for line in file: @@ -100,9 +102,14 @@ if part == 2: #print(programs) #print(instructions) - print(len(instructions)) + #print(len(instructions)) - for r in range(0,1000000000): + duplicates = [] + done = False + indx = 0 + while not done: + #print(r,list(programs)) + #input() for idx,i in enumerate(instructions): inst = parse_input(i) #print(idx,end=' ') @@ -122,11 +129,15 @@ if part == 2: else: print(inst) input() - if r % 10000 == 0: - print(r) + + + if start_value == list(programs): + #print(start_value) + #print(list(programs)) + done = True + duplicates.append(list(programs)) + indx += 1 - for i in programs: - print(i,end='') - print() \ No newline at end of file + print(''.join(duplicates[(1000000000%indx)-1])) diff --git a/2017/17/17.md b/2017/17/17.md new file mode 100644 index 0000000..bfcfc69 --- /dev/null +++ b/2017/17/17.md @@ -0,0 +1,92 @@ +## \-\-- Day 17: Spinlock \-\-- + +Suddenly, whirling in the distance, you notice what looks like a +massive, [pixelated +hurricane]{title="You know, as opposed to all those non-pixelated hurricanes you see on TV."}: +a deadly [spinlock](https://en.wikipedia.org/wiki/Spinlock). This +spinlock isn\'t just consuming computing power, but memory, too; vast, +digital mountains are being ripped from the ground and consumed by the +vortex. + +If you don\'t move quickly, fixing that printer will be the least of +your problems. + +This spinlock\'s algorithm is simple but efficient, quickly consuming +everything in its path. It starts with a circular buffer containing only +the value `0`, which it marks as the *current position*. It then steps +forward through the circular buffer some number of steps (your puzzle +input) before inserting the first new value, `1`, after the value it +stopped on. The inserted value becomes the *current position*. Then, it +steps forward from there the same number of steps, and wherever it +stops, inserts after it the second new value, `2`, and uses that as the +new *current position* again. + +It repeats this process of *stepping forward*, *inserting a new value*, +and *using the location of the inserted value as the new current +position* a total of `2017` times, inserting `2017` as its final +operation, and ending with a total of `2018` values (including `0`) in +the circular buffer. + +For example, if the spinlock were to step `3` times per insert, the +circular buffer would begin to evolve like this (using parentheses to +mark the current position after each iteration of the algorithm): + +- `(0)`, the initial state before any insertions. +- `0 (1)`: the spinlock steps forward three times (`0`, `0`, `0`), and + then inserts the first value, `1`, after it. `1` becomes the current + position. +- `0 (2) 1`: the spinlock steps forward three times (`0`, `1`, `0`), + and then inserts the second value, `2`, after it. `2` becomes the + current position. +- `0  2 (3) 1`: the spinlock steps forward three times (`1`, `0`, + `2`), and then inserts the third value, `3`, after it. `3` becomes + the current position. + +And so on: + +- `0  2 (4) 3  1` +- `0 (5) 2  4  3  1` +- `0  5  2  4  3 (6) 1` +- `0  5 (7) 2  4  3  6  1` +- `0  5  7  2  4  3 (8) 6  1` +- `0 (9) 5  7  2  4  3  8  6  1` + +Eventually, after 2017 insertions, the section of the circular buffer +near the last insertion looks like this: + + 1512 1134 151 (2017) 638 1513 851 + +Perhaps, if you can identify the value that will ultimately be *after* +the last value written (`2017`), you can short-circuit the spinlock. In +this example, that would be `638`. + +*What is the value after `2017`* in your completed circular buffer? + +Your puzzle answer was `725`. + +## \-\-- Part Two \-\-- {#part2} + +The spinlock does not short-circuit. Instead, it gets *more* angry. At +least, you assume that\'s what happened; it\'s spinning significantly +faster than it was a moment ago. + +You have good news and bad news. + +The good news is that you have improved calculations for how to stop the +spinlock. They indicate that you actually need to identify *the value +after `0`* in the current state of the circular buffer. + +The bad news is that while you were determining this, the spinlock has +just finished inserting its fifty millionth value (`50000000`). + +*What is the value after `0`* the moment `50000000` is inserted? + +Your puzzle answer was `27361412`. + +Both parts of this puzzle are complete! They provide two gold stars: +\*\* + +At this point, you should [return to your Advent calendar](/2017) and +try another puzzle. + +Your puzzle input was `329`{.puzzle-input}. diff --git a/2017/17/solution.py b/2017/17/solution.py new file mode 100644 index 0000000..15e7cd1 --- /dev/null +++ b/2017/17/solution.py @@ -0,0 +1,77 @@ +#!/bin/python3 +import sys,re +from pprint import pprint +sys.path.insert(0, '../../') +from fred import list2int + +input_f = 'input' + +part = 2 +######################################### +# # +# Part 1 # +# # +######################################### + +if part == 1: + jump = 0 + arr = [0] + pos = 0 + with open(input_f) as file: + jump = int(file.read().rstrip()) + + for i in range(1,2017+1): + #print(arr) + #print(len(arr),i) + pos = (pos+jump)%len(arr) + loc = (pos)+1 + #print(loc) + pos += 1 + arr.insert(loc,i) + #input() + + f_pos = arr.index(2017) + + + print(arr[f_pos-1],arr[f_pos],arr[f_pos+1]) + + +######################################### +# # +# Part 2 # +# # +######################################### +if part == 2: + jump = 0 + arr = [0] + pos = 0 + loc = 0 + with open(input_f) as file: + jump = int(file.read().rstrip()) + + prev = 0 + + for i in range(1,50000000+1): + #print(arr) + #print(len(arr),i) + pos = (pos+jump)%i + loc = (pos)+1 + #print(loc) + pos += 1 + + #arr.insert(loc,i) + #input() + if i%1000000 == 0: + print(i) + + if pos == 1: + #print('INSERT') + prev = i + #print(i-1) + #print(pos,loc) + print(prev) + + #f_pos = arr.index(0) + + + #print(arr[f_pos-1],arr[f_pos],arr[f_pos+1]) diff --git a/2017/18/18.md b/2017/18/18.md new file mode 100644 index 0000000..ff9eaa8 --- /dev/null +++ b/2017/18/18.md @@ -0,0 +1,79 @@ +## \-\-- Day 18: Duet \-\-- + +You discover a tablet containing some strange assembly code labeled +simply \"[Duet](https://en.wikipedia.org/wiki/Duet)\". Rather than +bother the sound card with it, you decide to run the code yourself. +Unfortunately, you don\'t see any documentation, so you\'re left to +figure out what the instructions mean on your own. + +It seems like the assembly is meant to operate on a set of *registers* +that are each named with a single letter and that can each hold a single +[integer](https://en.wikipedia.org/wiki/Integer). You suppose each +register should start with a value of `0`. + +There aren\'t that many instructions, so it shouldn\'t be hard to figure +out what they do. Here\'s what you determine: + +- `snd X` *[plays a + sound]{title="I don't recommend actually trying this."}* with a + frequency equal to the value of `X`. +- `set X Y` *sets* register `X` to the value of `Y`. +- `add X Y` *increases* register `X` by the value of `Y`. +- `mul X Y` sets register `X` to the result of *multiplying* the value + contained in register `X` by the value of `Y`. +- `mod X Y` sets register `X` to the *remainder* of dividing the value + contained in register `X` by the value of `Y` (that is, it sets `X` + to the result of `X` + [modulo](https://en.wikipedia.org/wiki/Modulo_operation) `Y`). +- `rcv X` *recovers* the frequency of the last sound played, but only + when the value of `X` is not zero. (If it is zero, the command does + nothing.) +- `jgz X Y` *jumps* with an offset of the value of `Y`, but only if + the value of `X` is *greater than zero*. (An offset of `2` skips the + next instruction, an offset of `-1` jumps to the previous + instruction, and so on.) + +Many of the instructions can take either a register (a single letter) or +a number. The value of a register is the integer it contains; the value +of a number is that number. + +After each *jump* instruction, the program continues with the +instruction to which the *jump* jumped. After any other instruction, the +program continues with the next instruction. Continuing (or jumping) off +either end of the program terminates it. + +For example: + + set a 1 + add a 2 + mul a a + mod a 5 + snd a + set a 0 + rcv a + jgz a -1 + set a 1 + jgz a -2 + +- The first four instructions set `a` to `1`, add `2` to it, square + it, and then set it to itself modulo `5`, resulting in a value of + `4`. +- Then, a sound with frequency `4` (the value of `a`) is played. +- After that, `a` is set to `0`, causing the subsequent `rcv` and + `jgz` instructions to both be skipped (`rcv` because `a` is `0`, and + `jgz` because `a` is not greater than `0`). +- Finally, `a` is set to `1`, causing the next `jgz` instruction to + activate, jumping back two instructions to another jump, which jumps + again to the `rcv`, which ultimately triggers the *recover* + operation. + +At the time the *recover* operation is executed, the frequency of the +last sound played is `4`. + +*What is the value of the recovered frequency* (the value of the most +recently played sound) the *first* time a `rcv` instruction is executed +with a non-zero value? + +To begin, [get your puzzle input](18/input). + +Answer: diff --git a/2017/18/solution.py b/2017/18/solution.py new file mode 100644 index 0000000..66c0cf8 --- /dev/null +++ b/2017/18/solution.py @@ -0,0 +1,42 @@ +#!/bin/python3 +import sys,re +from pprint import pprint +sys.path.insert(0, '../../') +from fred import list2int + +input_f = 'test' + +part = 1 +######################################### +# # +# Part 1 # +# # +######################################### + +def parse_input(input_str): + pattern = r"^(s(\d+)|x(\d+)/(\d+)|p([a-zA-Z])/([a-zA-Z]))$" + + match = re.match(pattern, input_str) + if match: + if match.group(2): + return ('s', int(match.group(2))) + elif match.group(3) and match.group(4): + return ('x', int(match.group(3)), int(match.group(4))) + elif match.group(5) and match.group(6): + return ('p', match.group(5), match.group(6)) + return None + +if part == 1: + with open(input_f) as file: + for line in file: + + + + +######################################### +# # +# Part 2 # +# # +######################################### +if part == 2: + exit()