diff --git a/2017/24/24.md b/2017/24/24.md new file mode 100644 index 0000000..09b66ed --- /dev/null +++ b/2017/24/24.md @@ -0,0 +1,65 @@ +## \-\-- Day 24: Electromagnetic Moat \-\-- + +The CPU itself is a large, black building surrounded by a bottomless +pit. Enormous metal tubes extend outward from the side of the building +at regular intervals and descend down into the void. There\'s no way to +cross, but you need to get inside. + +No way, of course, other than building a *bridge* out of the magnetic +components strewn about nearby. + +Each component has two *ports*, one on each end. The ports come in all +different types, and only matching types can be connected. You take an +inventory of the components by their port types (your puzzle input). +Each port is identified by the number of *pins* it uses; more pins mean +a stronger connection for your bridge. A `3/7` component, for example, +has a type-`3` port on one side, and a type-`7` port on the other. + +Your side of the pit is metallic; a perfect surface to connect a +magnetic, *zero-pin port*. Because of this, the first port you use must +be of type `0`. It doesn\'t matter what type of port you end with; your +goal is just to make the bridge as strong as possible. + +The *strength* of a bridge is the sum of the port types in each +component. For example, if your bridge is made of components `0/3`, +`3/7`, and `7/4`, your bridge has a strength of `0+3 + 3+7 + 7+4 = 24`. + +For example, suppose you had the following components: + + 0/2 + 2/2 + 2/3 + 3/4 + 3/5 + 0/1 + 10/1 + 9/10 + +With them, you could make the following valid bridges: + +- `0/1` +- `0/1`\--`10/1` +- `0/1`\--`10/1`\--`9/10` +- `0/2` +- `0/2`\--`2/3` +- `0/2`\--`2/3`\--`3/4` +- `0/2`\--`2/3`\--`3/5` +- `0/2`\--`2/2` +- `0/2`\--`2/2`\--`2/3` +- `0/2`\--`2/2`\--`2/3`\--`3/4` +- `0/2`\--`2/2`\--`2/3`\--`3/5` + +(Note how, as shown by `10/1`, order of ports within a component +doesn\'t matter. However, you may only use each port on a component +once.) + +Of these bridges, the *strongest* one is `0/1`\--`10/1`\--`9/10`; it has +a strength of `0+1 + 1+10 + 10+9 = 31`. + +*What is the strength of the strongest bridge you can make* with the +components you have available? + +To begin, [get your puzzle input](24/input). + +Answer: + diff --git a/2017/24/solution.py b/2017/24/solution.py new file mode 100644 index 0000000..4b5e09c --- /dev/null +++ b/2017/24/solution.py @@ -0,0 +1,29 @@ +#!/bin/python3 +import sys,re +from pprint import pprint +sys.path.insert(0, '../../') +from fred import list2int + +input_f = 'test' + +part = 1 +######################################### +# # +# Part 1 # +# # +######################################### + +if part == 1: + with open(input_f) as file: + for line in file: + + + + +######################################### +# # +# Part 2 # +# # +######################################### +if part == 2: + exit() diff --git a/2017/25/25.md b/2017/25/25.md new file mode 100644 index 0000000..967960f --- /dev/null +++ b/2017/25/25.md @@ -0,0 +1,99 @@ +## \-\-- Day 25: The Halting Problem \-\-- + +Following the twisty passageways deeper and deeper into the CPU, you +finally reach the core of the computer. +Here, in the expansive central chamber, you find a grand apparatus that +fills the entire room, suspended nanometers above your head. + +You had always imagined CPUs to be noisy, chaotic places, bustling with +activity. Instead, the room is quiet, motionless, and dark. + +Suddenly, you and the CPU\'s *garbage collector* startle each other. +\"It\'s not often we get many visitors here!\", he says. You inquire +about the stopped machinery. + +\"It stopped milliseconds ago; not sure why. I\'m a garbage collector, +not a doctor.\" You ask what the machine is for. + +\"Programs these days, don\'t know their origins. That\'s the *Turing +machine*! It\'s what makes the whole computer work.\" You try to explain +that Turing machines are merely models of computation, but he cuts you +off. \"No, see, that\'s just what they *want* you to think. Ultimately, +inside every CPU, there\'s a Turing machine driving the whole thing! Too +bad this one\'s broken. [We\'re +doomed!](https://www.youtube.com/watch?v=cTwZZz0HV8I)\" + +You ask how you can help. \"Well, unfortunately, the only way to get the +computer running again would be to create a whole new Turing machine +from scratch, but there\'s no *way* you can-\" He notices the look on +your face, gives you a curious glance, shrugs, and goes back to sweeping +the floor. + +You find the *Turing machine blueprints* (your puzzle input) on a tablet +in a nearby pile of debris. Looking back up at the broken Turing machine +above, you can start to identify its parts: + +- A *tape* which contains `0` repeated infinitely to the left and + right. +- A *cursor*, which can move left or right along the tape and read or + write values at its current position. +- A set of *states*, each containing rules about what to do based on + the current value under the cursor. + +Each slot on the tape has two possible values: `0` (the starting value +for all slots) and `1`. Based on whether the cursor is pointing at a `0` +or a `1`, the current state says *what value to write* at the current +position of the cursor, whether to *move the cursor* left or right one +slot, and *which state to use next*. + +For example, suppose you found the following blueprint: + + Begin in state A. + Perform a diagnostic checksum after 6 steps. + + In state A: + If the current value is 0: + - Write the value 1. + - Move one slot to the right. + - Continue with state B. + If the current value is 1: + - Write the value 0. + - Move one slot to the left. + - Continue with state B. + + In state B: + If the current value is 0: + - Write the value 1. + - Move one slot to the left. + - Continue with state A. + If the current value is 1: + - Write the value 1. + - Move one slot to the right. + - Continue with state A. + +Running it until the number of steps required to take the listed +*diagnostic checksum* would result in the following tape configurations +(with the *cursor* marked in square brackets): + + ... 0 0 0 [0] 0 0 ... (before any steps; about to run state A) + ... 0 0 0 1 [0] 0 ... (after 1 step; about to run state B) + ... 0 0 0 [1] 1 0 ... (after 2 steps; about to run state A) + ... 0 0 [0] 0 1 0 ... (after 3 steps; about to run state B) + ... 0 [0] 1 0 1 0 ... (after 4 steps; about to run state A) + ... 0 1 [1] 0 1 0 ... (after 5 steps; about to run state B) + ... 0 1 1 [0] 1 0 ... (after 6 steps; about to run state A) + +The CPU can confirm that the Turing machine is working by taking a +*diagnostic checksum* after a specific number of steps (given in the +blueprint). Once the specified number of steps have been executed, the +Turing machine should pause; once it does, count the number of times `1` +appears on the tape. In the above example, the *diagnostic checksum* is +*`3`*. + +Recreate the Turing machine and save the computer! *What is the +diagnostic checksum* it produces once it\'s working again? + +To begin, [get your puzzle input](25/input). + +Answer: + diff --git a/README.md b/README.md index a14591e..bfb5bef 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,7 @@ # AdventOfCode ## 2017 - + |*─┤[]├──┘│┌──────┘o┘└──────┘┌┘┌───[─]───────┤| 23* |┌┘┌┘┌──────┴o┌─┘│ o┤ ├─┘┌────┘┌*o─┴─┘└┴───┘| 22** |├───┬┴┴┴┤└──o┌┘└┤ FC├─*o────────┴──┘├┴┴┴┴┬──┘| 21** |│o┬─┤ ├────┤┌─┤ LP├─┘┌──|(────────┤ ├──*| 20**