Part 1: Create a 128x128 grid. Generate each row by taking the knot hash of
salt-{index}. The bits of the hash represent if a tile in the grid isfree(0) orused(1).
Given your salt as input, how many squares are
used?
Part 1: Multiple layers are defined with rules of the form:
- {index}: {depth}
Each layer will start at position 0, then once per tick will advance towards depth. Once it hits
depth-1, it will return to position 0, taking2*depth-1per full cycle.
Calculate the sum of
index * depthfor any scanners that are at position0when you pass through them given an initial starting time.
On of the advantages of working in computer programming is that I can work from anywhere I have a computer and an internet connection. One of the disadvantages is that many of the resources that I need to do my job are locked to only be accessible within a specific network (albeit with a bastion host).
I long ago set up my SSH config to create an SSH tunnel and I can proxy many applications through that just by setting the HTTP_PROXY and/or HTTPS_PROXY environment variables. The downside of this though is that if I’m actually on a ‘safe’ network, there’s no reason to use the bastion host and I would actually be putting extra load on it.
My goal: write something that would let me automatically proxy applications when I need to but not when I don’t.
Part 1: A network of nodes is defined by a list of lines formatted as such:
2 <-> 0, 3, 4
> In this case, node `2` is connected to `0`, `3`, and `4` and vice versa.
> How many nodes are in the group that contains the node `0`?
First, load the data into an [[wiki:adjacency map]]():
```python
nodes = set()
neighbors = collections.defaultdict(set)
for line in lib.input():
source, destinations = line.split('<->')
source = int(source.strip())
nodes.add(source)
for destination in destinations.strip().split(','):
destination = int(destination.strip())
nodes.add(destination)
neighbors[source].add(destination)
neighbors[destination].add(source)
Then, write a function that can take a node and recursively expand until it finds all nodes in the same group:
Part 1: Work on a hex grid:
\ n /
nw +–+ ne
/
-+ +-
\ /
sw +–+ se
/ s \
> Given a series of steps (`n`, `se`, `ne`) etc, how many steps away from the origin do you end up?
This problem mostly comes down to representation. [This post from Red Blob games](https://www.redblobgames.com/grids/hexagons/) has the best write up of how to use hex coordinate systems I've ever seen. Since it handles distances better, I'm going to use a cube coordinate system, where each hex actually has an `x`, `y`, and `z` coordinate. Now that is decided, we can write up a map to translate directions into offsets, a way to add points together, and a distance function:
```python
neighbors = {
'n' : (0, 1, -1),
'ne': (1, 0, -1),
'se': (1, -1, 0),
's' : (0, -1, 1),
'sw': (-1, 0, 1),
'nw': (-1, 1, 0),
}
def add(p1, p2):
x1, y1, z1 = p1
x2, y2, z2 = p2
return (x1 + x2, y1 + y2, z1 + z2)
def move(p, d):
return add(p, neighbors[d.strip()])
def distance(p1, p2):
x1, y1, z1 = p1
x2, y2, z2 = p2
return max(abs(x1 - x2), abs(y1 - y2), abs(z1 - z2))
That makes code for the actual question nice and clean:
Whenever I create my yearly reading list, I need a way to order the books. Sure, I could just shuffle them normally, but that leads me to the temptation of cheating and re-shuffling them so that the books I want to read most are first. What I really need is a shuffle that will shuffle the same way every time.
Enter: hashsort
Part 1: Starting with a list of the numbers from
1tonand a list oflengths(as input):
- Initialize
current_positionandskip_sizeto0- For each
lengthelement in thelengthslist:- Reverse the first
lengthelements of the list (starting atcurrent_position)- Move forward by
lengthplusskip_size- Increment
skip_sizeby 1
After applying the above algorithm, what is the product of the first two elements in the list (from the original first position, not the
current_position)?
A long time ago1, in a galaxy far, far away2, I moved my blog from WordPress to a custom written static blog generator in Racket. And for a while, all was well.
Part 1: An input stream can contain:
groupsare delimited by{and},groupsare nestable and may containgarbageor data (objects within agroupare comma delimited)garbageis delimited by<and>,groupscannot be nested withingarbage, a!withingarbageis an escape character:!>does not end a garbage segment
The score of a single group is equal to how many times it is nested (the innermost group of
{{{}}}has score3).
The score of a stream is the sum of the scores of all groups in that stream.
What is the total score of your input?
Part 1: Given a set of registers initialized to 0, interpret a series of instruction of the form:
{register} (inc|dec) {number|register} if {number|register} (<|<=|=|!=|=>|>) {number|register}
What is the largest value in any register?