Source: Inventory Management System
Part 1: Given a list of strings, count how many contain exactly two of a letter (
a) and how many contain exactly three of a letter (b). Calculatea*b.
Part 1: Given a list of strings, count how many contain exactly two of a letter (
a) and how many contain exactly three of a letter (b). Calculatea*b.
Part 1: Given a list of numbers (positive and negative) calculate the sum.
Let’s do it again! I’m starting a day late, but much better than last year 😄!
This time around, I’m hoping to solve each problem in both Python and Racket, both to show an example of how the languages differ and … well, because I can 😇.
EDIT 2018-12-05: Yeah… I’m not actually going to do these in both Racket and Python. The solutions are ending up being near direct translations. Since there are probably fewer people solving these in Racket, I’ll do that first and Python eventually™.
As always, these problems are wonderful to try to solve yourself. If you agree, stop reading now. This post isn’t going anywhere.
If you’d like to see the full form of any particular solution, you can do so on GitHub (including previous years and possibly some I haven’t written up yet): jpverkamp/advent-of-code
As I did with last year / yesterday, I’ve written up a series of posts for the Advent of Code 2017 problems. Again, I didn’t manage to write them up as I did them, but this time around I least I finished mostly on time.
As I did last year, I’m going to solve the Advent of Code problems again this year.
Or that was the plan. It turns out that instead I put down my blog for almost a year and a half and never quite got around to doing these problems. So I’m actually backdating these posts from the early days of 2018 to where they would have been had I solved them on time. They’re still interesting problems, so give them a read.
Part 1: Implement a Turing machine defined as such:
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.
…
> What is the final number of `1s` on the tape?
Most of this problem actually came down to reading the input:
```python
# Map of (current state, current value, key) -> value
# key is one of value, offset, state
transitions = {}
breakpoint = 0
state = None
pointer = 0
one_bits = set()
for line in lib.input():
line = line.strip('- ')
arg = line.split()[-1][:-1]
if arg == 'steps':
arg = line.split()[-2]
try:
arg = int(arg)
except:
pass
# Store values based on that argument
if line.startswith('Begin'):
state = arg
elif line.startswith('Perform'):
breakpoint = arg
elif line.startswith('In'):
current_state = arg
elif line.startswith('If'):
current_value = arg
elif line.startswith('Write'):
transitions[current_state, current_value, 'value'] = arg == 1
elif line.startswith('Move'):
transitions[current_state, current_value, 'offset'] = 1 if arg == 'right' else -1
elif line.startswith('Continue'):
transitions[current_state, current_value, 'state'] = arg
As we did in part 1 of day 22, we’ll use a set to store the current state (store 1, if an index is not in the set, it’s 0). That gives us the ability to grow unbounded (so long as we have enough RAM).
Part 1: Given a series of reversible components of the form
3/4(can connect a3on one end to a4on the other), form a bridge of components. The bridge’s strength is equal to the sum of component values. So0/3, 3/7, and 7/4has a strength of0+3 + 3+7 + 7+4 = 24.
What is the strongest possible bridge?
Part 1: Create a variation of the previous DuetVM with only the following four instructions:
set X Ysets registerXtoYsub X Yset registerXtoX - Ymul X Ysets registerXtoX * Yjnz X Yjumps with an offset of the value ofY, iffXis not equal to zero
If you run the given program, how many times is
mulinvoked?
Part 1: Implement a cellular automaton on an infinite grid of
.and#pixels such that:
- Start at
(0, 0), facingUp- Repeat:
- If the cursor is on
.swap it to#and turnLeft- If the cursor is on
#swap it to.and turnRight- Either way, after turning, move forward once
After 10,000 iterations, how many pixels were turned from
.to#?
Part 1: Start with an input image made of
.and#pixels. Forniterations, break the image into blocks:
- If the current size is even, break the image into 2x2 chunks and replace each with a 3x3 chunk
- If the current size is odd, break the image into 3x3 chunks and replace each with a 4x4 chunk
The replacement rules will be specified in the following format (example is a 3x3 -> 4x4 rule):
.#./..#/### => #..#/..../..../#..#In that example, replace this:
.#. ..# ###With this:
#..# .... .... #..#Any rotation or reflection of a chunk can be used to match the input of a replacement rule.
After
n = 18iterations, how many#pixels are there?