Advent of code

This repository is dedicated to my attempts at advent of code anno 2017.

Some of the code will be somewhat quick and dirty when I first upload it, since it might be an initial attempt, however things should become somewhat clean after I've rewritten the attempts later.

The 1st of December

For the first challenge, part one, one had to review a sequence of digits and find the sum of all the digits, which match the next digit in the list. This list is circular, thus the last digit will be able to match with the first digit, such that `1221` will have a sum of `3`.

For the second part, one now had to, instead of considering the next digit in the list, consider the digit halfway around the circular list, so `1212` would produce a sum of `6`.

The 2nd of December

For the second challenge, part one, the objective was to look through a bunch of lists, find the maximum and minimum value and then subtract these for each list. In the end, the results of the different subtractions had to be summed up and this would be the result.

For the second part, the calculation of the checksum had changed to now being calculated from finding the only pair of evenly divisible numbers from each list and then sum up the results of the divisions.

The 3rd of December

The goal was to look at a spiral which followed this pattern:

and then figure out what the manhattan distance is from the input number to the center. I noticed a pattern in the bottom left corner, `9, 25, 49, ...` and then saw that the squareroot of that number concidentally was the length of the side as well. Because of this, I could find the closests number to my input, where the squareroot of that number followed that pattern, `3,5,7`. After I knew what the side length was, I could figure out where my input number was, relative to that and from there I could find the actual distance to the center.

For the second part, the spiral had changed slightly. Now every number was the sum of all surrounding numbers, so the spiral would look like this:

I was not able to find a particular pattern in this, so I ended up building the spiral, using the fact that Ruby allows for hashes to have a default value, so I could set that to 0 and then iniate (0,0) => 1 and from there count the the numbers around it. The implementation is somewhat ugly.

The 4th of December

Given a list of words, one had to figure out if the given list is a valid passphrase. A passphrase consists of a series of words (lowercase letters) separated by spaces and there can be no duplicate words in the passphrase.

This first part was simply solved by converting each list to a set by calling uniq on it and then checking if the length is the same as for the original list. If not, there must have been some duplicates.

For the second part, if any word was a permutation of another word, this list was now not a valid passphrase. Because of this, it could be solved by looping through all words, taking the permutation and then checking if either of the permutation was already known and if so, the list was decided to be not a valid passphrase.

The 5th of December

The input is a list of the offsets for each jump to where one has to go in an array. Jumps are relative: -1 moves to the previous instruction, and 2 skips the next one. Start at the first instruction in the list. The goal is to follow the jumps until one leads outside the list. Also, each jump incremented the previous offset by one.

Because of the 'outside the list' requirement, one could simply loop on while input[i] != nil in Ruby, since Ruby doesn't throw an IndexOutOfBounds-exception. Therefore, for the first part, one simply had to loop on the beforementioned while and for each iteration, then calculate the new offset and increment a counter to check how many times it has taken, since the goal was to tell when we went out of bounds.

For the second part, the only difference was that whenever the offset jumped from was 3 or higher, the offset was instead decremented by one.