DEV Community: Christopher Nilsson

Advent of Code: 2020 Day 09 solutions

Christopher Nilsson — Wed, 09 Dec 2020 07:56:51 +0000

⚠️ SPOILER ALERT ⚠️
This is a post with my solutions and learning from the puzzle. Don't continue reading if you haven't tried the puzzle on your own yet.

If you want to do the puzzle, visit adventofcode.com/2020/day/9.

My programming language of choice is python and all examples below are in python.

Key learning

Window sliding

This puzzle teaches us to slide through an list of values using a window. It is possible to solve with nested for-loops and if-statements. But it gets much easier utilizing a window to operate on.

Puzzle

The puzzle is to validate number in a list. A number is valid if it is the sum of any of the 25 immediately previous numbers. All first 25 numbers are counted as valid. The input is a file with one number per line.

Example input:

Part 1

In part 1 we have to find the first number that is NOT valid.

Parsing input

# Parse directly into ints.
numbers = [
  int(line.strip())
  for line
  in open('09.input', 'r').readlines()
]

Solution (bad)

The first concept is to figure out how to traverse the list and keep track of the 25 previous number. A naive solution is to iterate back to all previous numbers and try out all possible combinations of sums. Here is a example of that naive thinking. I don't even want to think about the time complexity. Though it still solves the puzzle on my computer in an instant.

def part1(numbers):
    # Iterate all numbers
    for i, n in enumerate(numbers):
        # Skip "preamble"
        if i < 25:
            continue

        # Iterate all 25 previous numbers
        is_valid = False
        for j in range(i-25,i):
            # Try out all combinations to sum to n
            for k in range(i-25, i):
                if j != k:
                    if numbers[j] + numbers[k] == n:
                        is_valid = True
                        break
                if is_valid:
                    break
            if is_valid:
                break

        # If is not valid, then we found our answer
        if not is_valid:
            return n
print "Solution part 1: %d" % part1(numbers)

Solution (good)

Using the concept of a sliding window we can create a more performant and clean solution. The sliding window is a list containing the previous 25 elements.

After each iteration we append the current number at the end and pop the first element to keep the size consistent of 25 elements.

We can also improve our validation. One way is to calculate the differences between the values in the window with the current number n. If the lists of differences intersects with the window, then there are two values that sum up to n. Note: this assumes that it DOES NOT exist numbers that are half of n. Works on my input, might not work on yours.

from collections import deque
def part1(numbers):
    window = numbers[:25]

    for n in numbers[25:]:
        differences = set([n - x for x in window])
        is_valid = len(window.intersection(differences))

        if not is_valid:
            return n          # Found answer
        else:
            window.append(n)  # Append n at end of list
            window.pop(0)     # Remove first element of list
print "Solution part1: %d" % part1(numbers)

Solution (optimized)

If we think about performance it cost O(N) to pop the first element in lists. Using a deque it lowers the time-complexity. Deque:

appends and pops from either side of the deque with approximately the same O(1) performance in either direction

Deque also has a maxlen parameter which ensures that the window stays at a certain size.

To optimize the validation we could reuse the code from Day 01. Essentially it just gives us a early return once a valid number is found with worst case O(N) time complexity. The previous example requires iterating the window once and then doing an intersection. Set intersection has worst case of O(N^2) which looks slower. But the window size is set to 25, which makes the worst case O(500) which simplifies to O(1). So both variants have equal time complexity.

Here is the code:

from collections import deque

def valid(arr, n):
    differences = set()
    for x in arr:
        if n - x in differences:
            return True
        differences.add(x)
    return False

def part1(numbers):
    window = deque(numbers[:25], maxlen=25)
    for n in numbers[25:]:
        if not valid(window, n):
            return n
        window.append(n)
print "Solution part1: %d" % part1(numbers)

Part 2

In part 2 we use the invalid number we find in part 1. We have now to find a contigous set of at least two numbers which sum to that invalid number. The answer is the sum of the largest and smallest number in that set.

Using the learning from part 1 we can jump into the clean solution using a sliding window. While iterating the list of numbers we push the current n to the window. Then if the window-sum is too big we pop the first element. And continue doing so as until the window-sum is equal to our invalid number, or smaller. We can keep track of the window-sum in a variable.

Solution

def part2(numbers, needle):
    window = deque()
    window_sum = 0                            # Sum for numbers currently in window

    for n in numbers:
        window.append(n)
        window_sum += n

        while window_sum > needle:            # Pop head until window_sum is within limit
            window_sum -= window.popleft()
        if window_sum == needle:              # Result found
            return max(window) + min(window)  # Sum the smallest and largest

solution_part_1 = part1(numbers)
print "Solution part 2: %d " part2(numbers, solution_part_1)

Thanks for reading!

I hope these solutions were insightful for you.

Complete code can be found at: github.com/cNille/AdventOfCode/blob/master/2020/09.py

Advent of Code: 2020 Day 08

Christopher Nilsson — Tue, 08 Dec 2020 07:30:48 +0000

⚠️ SPOILER ALERT ⚠️
This is a post with my solutions and learning from the puzzle. Don't continue reading if you haven't tried the puzzle on your own yet.

If you want to do the puzzle, visit adventofcode.com/2020/day/8.

My programming language of choice is python and all examples below are in python.

Key learning

Simple compiler

This puzzle is a really simple compiler where we execute one of three instructions and only keep track of one value in memory. For those beginning to learn programmingmthis is valuable lesson to start understanding compilers and some of the core concepts of code.

Puzzle

The puzzle about is to executing a set of instructions according to a specification. We have three operators jmp, acc, nop. Each instuction is one operator followed
by a value.

Quoted from advent of code:

acc increases or decreases a single global value called the accumulator by the value given in the argument. For example, acc +7 would increase the accumulator by 7. The accumulator starts at 0. After an acc instruction, the instruction immediately below it is executed next.
jmp jumps to a new instruction relative to itself. The next instruction to execute is found using the argument as an offset from the jmp instruction; for example, jmp +2 would skip the next instruction, jmp +1 would continue to the instruction immediately below it, and jmp -20 would cause the instruction 20 lines above to be executed next.
nop stands for No OPeration - it does nothing. The instruction immediately below it is executed next.

Example input:

nop +0
acc +1
jmp +4
acc +3
jmp -3
acc -99
acc +1
jmp -4
acc +6

Part 1

The instructions we receive as input creates a program with an infinite loop. The puzzle is to figure out what the accumulator is at the end of first loop.

I'm using a set for keeping track of where the instruciton-cursor has been. With that we know when the first loop is complete.

Parsing input

# Read in instructions from file
lines = [x.strip() for x in open('08.input', 'r').readlines() if x != '']

# Create tuples (x,y) where x is instruction and y is value
lines = [tuple(x.split()) for x in lines]

Solution: Quick

Just by reading part 1 one might write some code like this. A while-loop with some if statements containing operations to execute.

It might look like this:

def part1():
    lines_executed = set()
    cursor, accumulator = 0, 0

    while cursor not in lines_executed:
        instruction = lines[cursor][0]
        lines_executed.add(cursor)
        if instruction == 'jmp':
            cursor += int(lines[cursor][1])
        elif instruction == 'nop':
            cursor += 1
        elif instruction == 'acc':
            accumulator += int(lines[cursor][1])
            cursor += 1
        else:
            raise Exception('Unexpected instruction', instruction)
    return accumulator
print part1()

Solution: Extendable

Those that competed in AoC 2019 might have some flashbacks of the intcode that has it similarities. A simple compiler with a few instructions. That puzzle came back multiple times and we had to built upon our compiler with new operations and features. Investing in good structure at the beginning might be beneficial for coming puzzles.

Therefore I suggest finding a structure that you find more extendable.

Here is a suggestion:

def execute_program(lines):
    lines_executed = set()
    cursor = 0
    accumulator = 0

    def acc(lines, cursor, accumulator):
        return (cursor + 1, accumulator + int(lines[cursor][1]))

    def jmp(lines, cursor, accumulator):
        return (cursor + int(lines[cursor][1]), accumulator )

    def nop(lines, cursor, accumulator):
        return (cursor + 1, accumulator)

    while cursor not in lines_executed:
        instruction = lines[cursor][0]
        lines_executed.add(cursor)
        operations = {
            'jmp': jmp,
            'acc': acc,
            'nop': nop,
        }
        operation = operations[instruction]
        cursor, accumulator = operation(lines, cursor, accumulator)
    return accumulator

print "Solution part 1: %d" % execute_program(lines)

Do you find it more readable? Do you have other solutions or tips on making the compiler more extendable?

Part 2

We find out that one jmp or nop should be the other for executing the program without infinite loop.

Our execute program needs minimal change. Just a variable (terminated) to keep track if we reached the last instruction.

Then we just have to iterate through all jmp and nop, switch them, execute the program, and see if it was terminated or not.

Solution

def execute_program(lines):
    lines_executed = set()
    cursor = 0
    accumulator = 0

    def acc(lines, cursor, accumulator):
        return (cursor + 1, accumulator + int(lines[cursor][1]))

    def jmp(lines, cursor, accumulator):
        return (cursor + int(lines[cursor][1]), accumulator )

    def nop(lines, cursor, accumulator):
        return (cursor + 1, accumulator)

    terminated = False
    while not terminated and cursor not in lines_executed:
        instruction = lines[cursor][0]
        lines_executed.add(cursor)

        operations = {
            'jmp': jmp,
            'acc': acc,
            'nop': nop,
        }
        operation = operations[instruction]
        cursor, accumulator = operation(lines, cursor, accumulator)

        # Terminate if end at program
        terminated = cursor == len(lines)

    return terminated, accumulator


def part2(lines):
    for i in range(len(lines)):
        # Copy lines so that changes don't persist.
        local_lines = [x for x in lines]

        # Switch statement jmp/nop
        if 'jmp' in local_lines[i][0]:
            local_lines[i] = ('nop', local_lines[i][1])
        elif 'nop' in local_lines[i][0]:
            local_lines[i] = ('jmp', local_lines[i][1])

        terminated, result = execute_program(local_lines)

        if terminated:
            break
    return result
print "Solution part 2: %d" % part2(lines)

Thanks for reading!

I hope these solutions were insightful for you.

Complete code can be found at: github.com/cNille/AdventOfCode/blob/master/2020/08.py

Advent of Code: 2020 Day 07

Christopher Nilsson — Mon, 07 Dec 2020 21:12:33 +0000

⚠️ SPOILER ALERT ⚠️
This is a post with my solutions and learning from the puzzle. Don't continue reading if you haven't tried the puzzle on your own yet.

If you want to do the puzzle, visit adventofcode.com/2020/day/7.

My programming language of choice is python and all examples below are in python.

Key learning

Depth first search
Possibly on part 1: Breadth first search

This puzzle can be viewed as a "graph" problem with nodes and edges. A simple way for beginners to start is utilizing a queue or recursive function.

Puzzle

The puzzle describes relationship between bags in different colors. A bag in one color can contain a certain amount of bags in other colors.

Example input:

light red bags contain 1 bright white bag, 2 muted yellow bags.
dark orange bags contain 3 bright white bags, 4 muted yellow bags.
bright white bags contain 1 shiny gold bag.
muted yellow bags contain 2 shiny gold bags, 9 faded blue bags.
shiny gold bags contain 1 dark olive bag, 2 vibrant plum bags.
dark olive bags contain 3 faded blue bags, 4 dotted black bags.
vibrant plum bags contain 5 faded blue bags, 6 dotted black bags.
faded blue bags contain no other bags.
dotted black bags contain no other bags.

Part 1

The puzzle is to find all bags that can directly or indirectly contain a shiny gold bag. This can be viewed as a graph where bags are nodes and their relationships are edges.

An visualisation with example data:

           -> green bag -> grey bag
          /                       \
blue bag -                         -> shiny gold bag
          \                       /
            -> purple bag       /
                               /
white bag -------------------

Our goal is to traverse from shiny gold to the left and counting all nodes it finds. In this visualisation the answer is: white bag, blue, green, grey

Parsing input

A big part of the problem is deciding on data structure and how to parse the input into that structure.

For part 1 I aimed for this data-structure:

bags = {
  "light red": "1 bright white bag, 2 muted yellow bags.",
  "dark orange": "3 bright white bags, 4 muted yellow bags.",
  "bright white": "1 shiny gold bag.",
  "muted yellow":  "2 shiny gold bags, 9 faded blue bags.",
  ...
}

To keep track of which bags that contain a shiny gold bag I used a set to avoid duplicates. Below is the code to parse in the data. This approach does the simple parsing for bare minimum for part 1:

# Extract a list of lines from file
lines = [x.strip() for x in open('07.input', 'r').readlines()]

bags = {}
for l in lines:
    bag, contains = l.split('contain')
    bag = bag.replace(' bags','')
    bags[bag] = contains

Solution: Breadth first

Some bags will directly contain shiny gold. Those bags can in turn be contained in other bags, which will indirectly contain shiny gold.

This solution uses a work queue to traverse the "graph". Once we find a bag that can contain shiny gold we add it to the queue to check if it can be contained by another bag. We keep on doing so until the work queue is empty. For every bag we find we store it in the answer-set

This is a so called breadth first search. In this case I use a queue.

answer = set()                      # Bags containing 'shiny gold'
q = ['shiny gold']                  # Work queue for traversing bags
while len(q) != 0:
    current = q.pop(0)
    for bag in bags:
        if bag in answer:             # Skip if already counted.
            continue
        if current in bags[bag]:      # If bag contains current-bag,
            q.append(bag)             # add to queue and answer
            answer.add(bag)
print "Answer part 1: %d" % len(answer)

Solution: Depth first

Another solution is the depth first search. Both algorithms do fine in this puzzle and input-size. But in coming advent-of-code-puzzles, it is possible that only one will be sufficient enough. Therefore we practice both now.

This example is a depth first where I use a recursive function:

bags = {}
for l in lines:
    bag, contains = l.split('contain')
    bag = bag.replace(' bags','')
    bags[bag] = contains

def deep_search(bag, bags):
    contains = []
    for b in bags:
        if bag in bags[b]:
            # Add b to our list
            contains.append(b)
            # Add all children to b in our list
            contains.extend(deep_search(b, bags))

    # Remove duplicates
    return set(contains)

print "Answer: ", len(deep_search('shiny gold', bags))

Part 2

Parsing input

For part 2 I aimed for this data-structure:

bags = {
  "light red": { "bright white": 1, "muted yellow": 2 },
  "dark orange": { "bright white": 3, "muted yellow": 4 },
  "bright white": { "shiny gold": 1 },
  "muted yellow": { "shiny gold": 2, "faded blue": 9 },
  ...
}

In this way I can call bags['muted yellow']['shiny gold'] to find out how many shiny gold bags muted yellow contain.

This is a ugly "simple" way of solving it. Further down is an regex example which is cleaner.

bags = {}
q = []
for l in lines:
    # Clean line from unnecessary words.
    l = l.replace('bags', '').replace('bag', '').replace('.','')

    bag, contains = l.split('contain')
    bag = bag.strip()

    if 'no other' in contains: # If bag doesn't contain any bag
        bags[bag] = {}
        continue

    contains = contains.split(',')
    contain_dict = {}
    for c in [c.strip() for c in contains]:
        amount = c[:2]
        color = c[2:]
        contain_dict[color] = int(amount)
    bags[bag] = contain_dict

Solution

A good data structure enables us to do a clean solution. Here is an example with
a recursive function to count all bags:

def recursive_count(bag, bags):
    count = 1  # Count the bag itself

    contained_bags = bags[bag]
    for c in contained_bags:
        multiplier = contained_bags[c]
        count += multiplier * recursive_count(c, bags)
    return count

# Minus one to not count the shiny gold bag itself
result = recursive_count('shiny gold', bags) - 1
print "Result part 2: %d " % result

Alternative: With regex

A lot easier way to parse the data is using regex. Here is an example:

import re
from collections import defaultdict

bags = defaultdict(dict)
for l in lines:
    bag = re.match(r'(.*) bags contain', l).groups()[0]
    for count, b in re.findall(r'(\d+) (\w+ \w+) bag', l):
        bags[bag][b] = int(count)

def part1():
    answer = set()
    def search(color):
        for b in bags:
            if color in bags[b]:
                answer.add(b)
                search(b)
    search('shiny gold')
    return len(answer)

def part2():
    def search(bag):
        count = 1
        for s in bags[bag]:
            multiplier = bags[bag][s]
            count += multiplier * search(s)
        return count
    return search('shiny gold' ) - 1  # Rm one for shiny gold itself

Alternative: Network X

NetworkX is a good library for handling graphs. Haven't used it myself so much, but it appears quite often in the solutions megathread once there is a graph-problem.

There is a lot of documentation, but by reading solutions on the megathread you'll learn what common features to use.

Make sure you understand the above example with regex first before reading this. Here is an example solution with networkx:

import re
from collections import defaultdict
import networkx as nx

# Parse data
bags = defaultdict(dict)
for l in lines:
    bag = re.match(r'(.*) bags contain', l).groups()[0]
    for count, b in re.findall(r'(\d+) (\w+ \w+) bag', l):
        bags[bag][b] = { 'weight': int(count)}

# Create a graph in networkx
G = nx.DiGraph(bags)

def part1():
    # Reverse edges
    RG = G.reverse()
    # Get predecessors
    predecessors = nx.dfs_predecessors(RG, 'shiny gold')
    # Count predecessors
    return len(predecessors)
print(part1())

def part2():
    def search(node):
        count = 1
        # Iterate neighbors for node
        for n in G.neighbors(node):
            # Multiply weight with recursive search
            count += G[node][n]['weight'] * search(n)
        return count
    return search('shiny gold') - 1
print(part2())

Some benefit in using networkx is that it gives us more powerful tools than just traversing the graph. If we would like to find the shortest path, then this one-liner would help:

print(nx.shortest_path(G, source='bright red', target='shiny gold'))

Links:

networkx.org/documentation/networkx-2.3/reference/classes/digraph.html#
[networkx.org/documentation/networkx-2.3/reference/algorithms/generated/networkx.algorithms.shortest_paths.generic.shortest_path.html](https://networkx.org/documentation/networkx-2.3/reference/algorithms/generated/networkx.algorithms.shortest_paths.generic.shortest_path.html#networkx.algorithms.shortest_paths.generic.shortest_path

More python tools

These are tools worth having in back of your head while doing advent of code.

defaultdict: Useful when you don't want to think about initiating all values first.

deque: Useful when you want to pop left and right from a queue.

heapq: Amazing for tool or solving problems that involve extremes such as largest, smallest, optimal, etc.

Thanks for reading!

I hope these solutions were helpful for you.

Complete code can be found at: github.com/cNille/AdventOfCode/blob/master/2020/07.py

AoC: 2020 Day 06 AWK

Christopher Nilsson — Sun, 06 Dec 2020 10:11:35 +0000

⚠️ SPOILER ALERT ⚠️
This is a post with my solutions and learning from the puzzle. Don't continue reading if you haven't tried the puzzle on your own yet.

If you want to do the puzzle, visit adventofcode.com/2020/day/6.

AWK

AWK is an useful tool in the command-line when processing text-files. It has it's own "programming language" which makes it quite powerful.

Prerequisite understandings

Built-in variables:
There are built-in variables in AWK. These are useful to know when doing more complex calculations. In this code I will use FS and NF.

FS: Field seperator. It defaults to blank space " ".
NF: Number of fields. A counter for number of fields in current line.

No initialize required:
You don't need to initialize variables in AWK. Running var1++ is a valid statement. It will initialize var1 to 0 and then add one. The same principle applies to arrays.

array['X']++ initializes an empty array and then set the key-value. Will equal: { "X": 1 }

Structure:

pattern1 { ACTIONS; }
pattern2 { ACTIONS; }
pattern3 { ACTIONS; }

The pattern is usually a regex for matching lines. For example: /name/ { print $1}. There are two built-in patterns BEGIN and END. They run at the beginning and end of the program. They are good for initializing variables and output results.

Fetching fields:
In an action the fields are accessed by $1 notation. $0 is the whole line. $1 is the first field, $2 is the second field and so on. It is allowed to use variables:

echo "Hello! My name is Christopher." | awk '{ i=5; print $i }'
# Output: Christopher.

Solution

BEGIN {
  # Field separator. Sets each character as an own field
  FS="" 
}
{ # Matches all lines.
  if (NF == 0){ # NF - Number of fields. 0 means empty line
    # Part 1
    total = total + length(group)

    # Part 2
    for(letters in group) {
      if (group[letters] >= person_count) {
        total2 += 1
      }
    }

    # Reset values
    delete group
    person_count = 0
  } else {
    person_count += 1
    for(i=1; i <= NF; i++){ # Iterate through fields
      group[$i]++ 
    }
  }
}
END {
  printf "Solution part 1: " total "\n"
  printf "Solution part 2: " total2 "\n"
}

Save this file as 06.awk and then you can run it this way:

cat 06.input | awk -f 06.awk

Good reads about AWK

Advent of Code: 2020 Day 06

Christopher Nilsson — Sun, 06 Dec 2020 08:29:48 +0000

⚠️ SPOILER ALERT ⚠️
This is a post with my solutions and learning from the puzzle. Don't continue reading if you haven't tried the puzzle on your own yet.

If you want to do the puzzle, visit adventofcode.com/2020/day/6.

My programming language of choice is python and all examples below are in python.

Key learning

Sets and dictionaries

This puzzle teaches us how to counting unique elements in lists.

Puzzle

The puzzle is about groups of persons answering questions and the goal is to count the results.

The questions are named a-z. Only questions answered "yes" to are present in the input. The questions that one person answered are in one line. The groups of persons are separated by an empty line. Example input:

abc

a
b
c

ab
ac

a
a
a
a

b

Part 1

For each group, count the number of questions to which anyone answered "yes".
What is the sum of those counts?

Parse input-data:

If we read the file as a whole without stripping away all the new-line characters (\n) we can quickly group the groups by splitting on double new-line.

f = open('06.input', 'r')
data = f.read()
groups = data.strip().split('\n\n')

Solution:

Using a set as data structure is the simplest way to solve this puzzle. The built-in set in python will handle duplicates for us.

def part1(groups):
    total = 0
    for group in groups:
        # 1. Remove all new-line characters
        # 2. Extract unique letters by creating a set
        # 3. Count size of set
        total += len(set(group.replace('\n', '')))
    return total

Part 2

For each group, count the number of questions to which everyone answered
"yes". What is the sum of those counts?

In this puzzle a set won't do anymore as we need to keep track of occurrences for each letter.

Solution:

Using a dictionary here is more valuable as we can use the key-value store to keep track of occurence per letter.

def part2(groups):
    total = 0
    for group in groups:
        # Use dictionary to count occurrences of letters
        occurrences = {}
        for letter in group:
            if letter not in occurrences:
                occurrences[letter] = 0
            occurrences[letter] +=1

        # By splitting on new-line we get each persons answers.
        person_count = len(group.split('\n'))

        # Filter out letters that occur once per persons in group
        answered_by_all = [x == person_count for x in occurrences.values()]
        total += sum(answered_by_all)
    return total

Alternative solution

Python is all about making it easy for the developer. It exists already a library called Counter helping us with counting. Using it would make our code cleaner and would look like this:

from collections import Counter
def part2count(groups):
    total = 0
    for g in groups:
        # Use counter to count occurrences of letters
        letter_counter = Counter(g)

        # By splitting on new-line we get each persons answers.
        person_count = len(group.split('\n'))

        # Filter out letters that occur once per persons in group
        answered_by_all = [x == person_count for x in occurrences.values()]
        total += sum(answered_by_all)
    return total

Read more about Counter here: https://docs.python.org/3/library/collections.html

Set operations

These puzzles are essentially doing unions and intersections for each group. Using set operations it could look like this:

groups = open('06.input', 'r').read().strip().split('\n\n')

def part1set(groups):
    sets = [map(set, group.splitlines()) for group in groups]
    unions = [set.union(*s) for s in sets]
    return sum(map(len, unions))
print part1set(groups)

def part2set(groups):
    sets = [map(set, group.splitlines()) for group in groups]
    intersections = [set.intersection(*s) for s in sets]
    return sum(map(len, intersections))
print part2set(groups)

Functional style

These function are easy to write in a more functional style. My opinion is that it is less verbose, but a tad more complex to read.

def part1func(groups):
    return sum([
        len(set(group.replace('\n','')))
        for group
        in groups
    ])

def part2func(groups):
    return sum([
        len([x for x in Counter(group).values() if x == len(group.split('\n'))])
        for group
        in groups
    ])

Python tricks

Instead of filtering on a boolean comparison and check the length, we can just
map the element to the boolean and sum them. The sum will be treat the booleans
as 1 if True or 0 if False. See example below:

answered_by_all = [
  x
  for x
  in occurrences.values()
  if x == person_count
]
total += len(answered_by_all)

# Same as above
answered_by_all = [
  x == person_count
  for x
  in letter_counter.values()
]
total += sum(answered_by_all)

Deconstructing parameters

In the set function we do a set.union(*arr). What it does is that it spreads
the arrays elements as parameters. Example:

def my_function(a,b,c):
  return a * b * c

arr = [1,2,3]
res = my_function(*arr)
# Will output res = 6.

Thanks for reading!

I hope these solutions were helpful for you.

Complete code can be found at: github.com/cNille/AdventOfCode/blob/master/2020/06.py

Advent of Code: 2020 Day 05

Christopher Nilsson — Sat, 05 Dec 2020 07:39:24 +0000

SPOILER ALERT
This is a post with my solutions and learning from the puzzle. Don't continue
reading if you haven't tried the puzzle on your own yet.

If you want to do the puzzle, visit adventofcode.com/2020/day/5.

My programming language of choice is python and all examples below are in python.

Key learning

Binary numbers

This puzzle makes play with binaries. Though not explicitly, but knowing of binaries
will help out with this puzzle.

Puzzle

The puzzle today is about transforming seats to seat-ids using binary space partitioning.
The seats consist of 10 letters. The first 7 can be F or B and the last 3 can
be R or L. The letters stand for front, back, left, right.

The first 7 characters will either be F or B; these specify exactly one of
the 128 rows on the plane (numbered 0 through 127). Each letter tells you
which half of a region the given seat is in. Start with the whole list of
rows; the first letter indicates whether the seat is in the front (0 through
63) or the back (64 through 127). The next letter indicates which half of
that region the seat is in, and so on until you're left with exactly one row.

The last three characters will be either L or R; these specify exactly one of
the 8 columns of seats on the plane (numbered 0 through 7). The same process
as above proceeds again, this time with only three steps. L means to keep the
lower half, while R means to keep the upper half.

Every seat also has a unique seat ID: multiply the row by 8, then add the column.

Example input for some seats:

FBFBBFFRLR
BFBBBFBRLL
FBFBBFBLLL
BBBFFFBRRR
FBFFFBFRRL
BFFFFFFRLR

Part 1

The puzzle is to find the highest seat ID. To do this we need to transform the
seat-names to IDs and find the one with maximum value.

The puzzle differentiates the first seven and last three letters.
The value of the row should be multiplied with 8 and then the column value
is added. That is just a trick to make the puzzle seem more difficult.

Multiplying the row value with 8 is the same as shifting it with 3 bits because of
2^3 = 8. Adding the column value then is just concatenating the two binary strings.

We can treat the seat-name as a binary where B and R are 1 and the other 0.

def calc_id(seat):
    transformation = { 'F': '0', 'B': '1', 'L': '0', 'R': '1'}
    binary = "".join([transformation[x] for x in seat])
    return int(binary,2)

def part1(lines):
    ids = [calc_id(line) for line in lines]
    return max(ids)
print "Part 1 solution: %d " % part1(lines)

Part 2

The second is to find which pair of IDs are 2 steps apart.
We can reuse our calc_id function above.

def part2(lines):
    ids = [calc_id(line) for line in lines]

    for i in range(max(ids)):
        low = i - 1
        high = i + 1
        if  low in ids and high in ids and i not in ids:
            return i
print "Part 2 solution: %d " % part2(lines)

Alternative solutions

The transformation above could be solved with using an if statement in the list comprehension

def calc_id(seat):
    binary = "".join(['1' if x in ['B','R'] else '0' for x in seat])
    return int(binary,2)

Or using the string-replacement.

def calc_id(seat):
    binary = seat.replace('B', '1').replace('R', '1').replace('F', '0').replace('L', '0')
    return int(binary,2)

Using a translation table in python:

def calc_id(seat):
  translate_table = str.maketrans(dict(B="1", F="0", R="1", L="0"))
  return int(seat.translate(translate_table), 2)

Another alternative is to use binary calculations to transform the seat-names to IDs.
Here is an example:

def part1(lines):
    ids = []
    for line in lines:
        current = 0
        row = 64
        for letter in line[:7]:
            if letter == 'B':
                current += row
            row = row >> 1 # Shift right 1 bit (same as dividing by 2)

        current = current << 3 # Shift left 3 bits (same as multiplying with 8)

        row = 4
        for c in line[7:]:
            if c == 'R':
                current += row
            row = row >> 1 # Shift right 1 bit (same as dividing by 2)
        ids.append(current)

    return max(ids)

My initial train of thought of part 1 was to find the maximum value by sorting the strings and manually calculate the binary number. As B is before F in the alphabet you could do sort the lines to get max row-value without even transforming to binary. Though R is after L and the column value will get reversed sorted. I forgot the reversed sorting on the column values, therefore failed and changed tactics. Guessing that was the purpose of AoC to differentiate column and row values.

This would be a full solution for part 1:

sorted_data = sorted([
  line.replace('R','B').replace('L','F')
  for line
  in lines
])
print sorted_data[0]
# Step 2: Manually transform string to binary-string and then to
#         decimal with help of a online-calculator.

A last alternative: An unreadable oneliner for part 1:

def part1(lines):
  return max([
    int("".join([{ 'F': '0', 'B': '1', 'L': '0', 'R': '1'}[letter] or letter in line]), 2)
    for line in lines])

Python tips

Transform dictionaries

Dictionaries is a nice way to transform values during AoC puzzles. As I did in
the part 1 above:

transformation = {
  'F': '0',
  'B': '1',
  'L': '0',
  'R': '1'
}

transformation['F'] # Returns '0'
transformation['B'] # Returns '1'
transformation['L'] # Returns '0'
transformation['R'] # Returns '1'

"".join(list)

To concatenate an array of strings it's easiest to use the join-function.
The join-function is called on a string that will work as a delimiter. A empty
string would then join the array-strings without delimiter.

",".join['comma','seperated','string']
# => "comma,seperated,string"
"".join['no','seperation','at','all']
# => "noseperationatall"

int('10101010', 2)

Using int() we can convert strings to numbers. If we want to convert a binary
string we have to set the base to 2.

# Converting string using base 2
int('10111', 2) # outputs: 23

# Hexadecimal example:
int('FF', 16) # outputs: 255

max(arr)

In our solution we got a array of numbers. Finding the maximum value can be tempting
to use an for-loop and a maximum_value variable.
The max() function in python can take in an array as argument and does it for
us.

max([6,2,3,8,3,9]) # outputs: 9

Thanks for reading!

I hope these solutions were helpful for you. Complete code can be found at:
github.com/cNille/AdventOfCode/blob/master/2020/05.py

Advent of Code: 2020 Day 04

Christopher Nilsson — Fri, 04 Dec 2020 07:56:02 +0000

SPOILER ALERT
This is a post with my solutions and learnings from the puzzle. Don't continue
reading if you haven't tried the puzzle on your own yet.

If you want to do the puzzle, visit adventofcode.com/2020/day/4.

My programming language of choice is python and all examples below are in python.

Key learnings

Debugging and testing

Todays puzzle has a number of specific requirements to follow. The key learning I took away from it too handle edge cases, follow specification and having a systematic way of debugging. A good practice would to create tests for the edge cases to ensure everything works as expected.

Puzzle

The challenge is to validate data for a thousand passport.

Example input for two passports:

ecl:gry pid:860033327 eyr:2020 hcl:#fffffd
byr:1937 iyr:2017 cid:147 hgt:183cm

iyr:2013 ecl:amb cid:350 eyr:2023 pid:028048884
hcl:#cfa07d byr:1929

They fields are defined as:

byr (Birth Year)
iyr (Issue Year)
eyr (Expiration Year)
hgt (Height)
hcl (Hair Color)
ecl (Eye Color)
pid (Passport ID)
cid (Country ID)

Part 1

All fields except for Country ID (cid) are mandatory.
Validate that all mandatory fields are present.

Parse input

First step is to save the input in a local file and parse it in python:

# Open the input file
inputfile = open('04.input', 'r')

# Parse lines
data = [x.strip() for x in inputfile.readlines()]

Solution

def part1(data):
    valid_passport_count = 0
    required_fields = ['byr' ,'iyr' ,'eyr' ,'hgt' ,'hcl' ,'ecl' ,'pid']

    # Variable to track number of required fields for current passport
    current = 0
    for line in data:
        if line == '':                              # Empty line indicates new passport
            if current == len(required_fields):
                valid_passport_count += 1
            current = 0
            continue

        for field in line.split():
            key, val = field.split(':')
            if key in required_fields:
                current += 1

    return valid_passport_count

print "Solution part 1: %d" % part1(data)

Part 2

The second part adds validation for each field. The requirements are:

byr (Birth Year) - four digits; at least 1920 and at most 2002.
iyr (Issue Year) - four digits; at least 2010 and at most 2020.
eyr (Expiration Year) - four digits; at least 2020 and at most 2030.
hgt (Height) - a number followed by either cm or in:
- If cm, the number must be at least 150 and at most 193.
- If in, the number must be at least 59 and at most 76.
hcl (Hair Color) - a # followed by exactly six characters 0-9 or a-f.
ecl (Eye Color) - exactly one of: amb blu brn gry grn hzl oth.
pid (Passport ID) - a nine-digit number, including leading zeroes.
cid (Country ID) - ignored, missing or not.

My Solution

This part will have as many variations of solutions as there are developers. The important part is to read carufully the requirements and test against edge-cases. I did my testing continuously by printing relevant variables while coding. The solution below is therefore not the whole "solution" as I see the process as important as the final code.

def valid(passport):
    # Validate mandatory fields
    fields = ['byr' ,'iyr' ,'eyr' ,'hgt' ,'hcl' ,'ecl' ,'pid']
    for f in fields:
        if(f not in passport):
            return False

    # Validate numerical
    if not ( 1920 <= int(passport['byr']) <= 2002):
        return False
    if not ( 2010 <= int(passport['iyr']) <= 2020):
        return False
    if not ( 2020 <= int(passport['eyr']) <= 2030):
        return False

    # Validate Height
    if 'cm' in passport['hgt'] and not (150 <= int(passport['hgt'][:-2]) <=193):
        return False
    elif 'in' in passport['hgt'] and not (59 <= int(passport['hgt'][:-2]) <= 76):
        return False
    if 'cm' not in passport['hgt'] and 'in' not in passport['hgt']:
        return False

    # Validate strings/enums
    if  passport['ecl'] not in ['amb', 'blu', 'brn','gry','grn','hzl','oth']:
        return False
    if re.match(r'^\#[0-9a-f]{6}$', passport['hcl']) is None:
        return False
    if re.match(r'^\d{9}$', passport['pid']) is None:
        return False

    return True

def part2(data):
    valid_passport_count = 0
    current = {}
    for line in data:
        if line == '':
            if valid(current):
                valid_passport_count += 1
            current = {}
            continue

        for field in line.split():
            field,val = field.split(':')
            current[field] = val
    return valid_passport_count

Comments

One edge-case I missed was the passport-id with 9 digits. I forgot to add start and end notation on the regex. A 10-digit passport-id was valid as it did in fact contain a 9-digit number. This off by one error was hard for me to find. The lesson learned is to test edge-cases.

Though it is not practical in a "competition" environment. Therefore I tested by using print continuously to track what got passed and what didn't.

Thanks for reading!

I hope these solutions were helpful for you. Just ask if anything was hard to grasp.

Complete code can be found at: github.com/cNille/AdventOfCode/blob/master/2020/04.py

Advent of code: 2020 Day 03

Christopher Nilsson — Thu, 03 Dec 2020 07:08:58 +0000

⚠️ SPOILER ALERT
This is a post with my solutions and learnings from the puzzle. Don't continue
reading if you haven't tried the puzzle on your own yet.

If you want to do the puzzle, visit adventofcode.com/2020/day/3.

My programming language of choice is python and all examples below are in python.

Key learnings

Functions and abstraction

Part 1 is solved using the learning from the previous days. Part 2 introduces a new key learning. By asking us to calculate several slopes it forces us to rewrite the code from part 1 and generalize it. This encourages us to create a function for the calculation and use a good code structure.

Puzzle

The puzzle is about counting amount of trees you'll encounter if you travel through a "forest" in a straight line. The input is a map over the forest where # is a tree and . is an open space.

Note:
The map is repeating horizontally. In this puzzle you can see it as returning to the left side once you reach the right edge of the map.

Example input:

..##.......
#...#...#..
.#....#..#.
..#.#...#.#
.#...##..#.
..#.##.....

Part 1

The angle you should travel in is described as a slope of right 3 and down 1. The answer is how many trees you'll hit if you traverse the map in this slope.

A visual representation of the puzzle:

Parse input

First step is to save the input in a local file and parse it in python:

# Open the input file
inputfile = open('03.input', 'r')

# Parse lines
data = [x.strip() for x in inputfile.readlines()]

Solution

def part1(data):
    x = 0                             # X is current column
    total = 0                         # Count of trees
    map_width = len(data[0])
    map_height = len(data)
    for y in range(map_height):       # Iterate each row
        if data[y][x] == '#':         # Use x,y as coordinates to check for tree
            total += 1                # Count if tree
        x = (x + 3) % map_width       # Jump 3 steps right (modulus to keep within map)
    return total

print "Solution part 1: %d" % part1(data)

Part 2

The second puzzle has the same input. Now you have to try multiple slopes:

Right 1, down 1
Right 3, down 1
Right 5, down 1
Right 7, down 1
Right 1, down 2

The answer is product of multiplying amount of trees encountered in the above slopes.

Solution

In this stage you'll realize it's easier to refactor your code into a function with the slope as parameter.

The last slope with down 2 forces us to use both columns and rows skipped as parameters to your function.

def part2(data):
    def traverse(right, down):              # Define a function for generalizing
        x = 0
        total = 0
        for i in range(len(data)):
            if i % down != 0:               # Skip rows according to "down"-variable
                continue
            if data[i][x] == '#':
                total += 1
            x = (x + right) % len(data[0])  # Use right-parameter
        return total

    # Use function to get values for each slope
    return traverse(1,1) * traverse(3,1) * traverse(5,1) * traverse(7,1) * traverse(1,2)

Alternative solutions

Functional style

A more functional approach would be:

def part1(data):
    def encountered((idx, row)):
      x_position = (idx * 3) % len(row)
      return row[x_position] == '#'

    trees_encountered = filter(encountered, enumerate(data))
    return len(trees_encountered)

def part2(data):
    def traverse(right, down):
      # Filter out jumped rows
      def filter_row((idx, row)):
        return idx % down == 0
      rows_hit = filter(filter_row, enumerate(data))

      # Filter out rows where we encounter a tree
      def encountered((idx, row)):
        x_position = (idx * right) % len(row)
        return row[x_position] == '#'
      trees_encountered = filter(encountered, rows_hit)

      return len(trees_encountered)

    return traverse(1,1) * traverse(3,1) * traverse(5,1) * traverse(7,1) * traverse(1,2)

List comprehensions

Python has a nice feature of list comprehensions. Once you get used to the syntax it is easy to follow. Though a lot happens in one row, so be careful to not overuse so that it gets hard to grasp.

def part2(data):
    def traverse(right, down):
      # Filter out jumped rows
      rows_hit = [
        row
        for idx, row
        in enumerate(data)
        if idx % down == 0
      ]

      # Filter out rows where we encounter a tree
      trees_encountered = [
        idx
        for idx, row
        in enumerate(rows_hit)
        if row[(idx * right) % len(row)] == '#'
      ]
      return len(trees_encountered)

    return traverse(1,1) * traverse(3,1) * traverse(5,1) * traverse(7,1) * traverse(1,2)

Thanks for reading!

I hope these solutions were helpful for you. Just ask if anything was hard to grasp.

Complete code can be found at: github.com/cNille/AdventOfCode/blob/master/2020/03.py

Advent of code: 2020 Day 02

Christopher Nilsson — Wed, 02 Dec 2020 06:48:34 +0000

SPOILER ALERT
This is a post with my solutions and learnings from the puzzle. Don't continue reading if you haven't tried the puzzle on your own yet.

If you want to do the puzzle, visit adventofcode.com.

My programming language of choice is python and all examples below are in python.

Key learnings

String handling

This puzzle teaches you to handle strings. They are handled differently in every programming language and it's valuable to get comfortable with them. I find that python makes it easy to work with strings, but in other languages it might require more getting used to. You are going to need string handling a lot during Advent of Code as the input file is most often a text-file.

Puzzle part 1

The puzzle is to count the number of valid passwords in your input according to a policy.

Example input:

1-3 a: abcde
1-3 b: cdefg
2-9 c: ccccccccc

Each line gives the password policy and then the password. The password policy indicates the lowest and highest number of times a given letter must appear for the password to be valid. For example, 1-3 a means that the password must contain a at least 1 time and at most 3 times.

Parse input

First step is to save the input in a local file and parse it in python:

# Open the input file
inputfile = open('02.input', 'r')

# Parse lines 
data = [x.strip() for x in inputfile.readlines()]

Solution

def part1(data):
    total = 0
    for x in data:
        span, letter, password = x.split()
        start, end = map(int, span.split('-'))

        count = password.count(letter[0])

        if start <= count <= end:
            total +=1
    return total

result = part1(data)
print("Result part 1: %d" % result)

Part 2

The second part has the same input, but the policy is changed.

Each policy actually describes two positions in the password, where 1 means the first character, 2 means the second character, and so on. (Be careful; Toboggan Corporate Policies have no concept of "index zero"!) Exactly one of these positions must contain the given letter. Other occurrences of the letter are irrelevant for the purposes of policy enforcement.

Solution

def part2(data):
    total = 0
    for x in data:
        span, letter, password = x.split()
        start, end = map(int, span.split('-'))

        password1 = password[start-1] == letter[0]
        password2 = password[end-1] == letter[0]

        # Count if either first or the other character is correct. (xor)
        if password1 != password2:
            total +=1
    return total

Alternative solutions

Functional style

Going for a more functional style can make the code a bit cleaner. E.g there are no mutable variables or loops in this case. Though it requires the programmer to be comfortable with filter, map, reduce functions and so on.

def validate(line):
  span, letter, password = x.split()
  start, end = map(int, span.split('-'))
  count = password.count(letter[0])
  return start <= count and count <= end

def part1(data):
  valid_passwords = filter(validate, data) 
  return len(valid_passwords)

Regex

Regex is a powerful tool to use instead of splitting the strings. In python I find it easier to split strings as I did above. But in some cases (or other languages) it can be helpful to use regex instead. Here is an example of how the validation function could look like:

import re
def validate(line):
    start, end, letter, pw = re.search(r'(\d+)-(\d+) (\w): (\w+)', line).groups()
    return int(start) <= pw.count(letter) <= int(end)

Python explanations

Splitting strings

As all lines have the same format 1-3 a: password I know that splitting on space them will always output an array with 3 elements. In python we can automatically destruct it:

span, letter, password = x.split()

# Is same as:
output = x.split(' ')
span = output[0]
letter = output[1]
password = output[2]

Parsing numbers

The map function takes two parameters; a transform-function and an array. By using int as transform-function it will transform the strings to an integer if it's parseable.

start, end = map(int, span.split('-'))

# Is same as:
a, b = span.split('-')
start = int(a)
end = int(b)

Double comparisons

Python has a sweet feature to allow two comparisons in this way:

if a <= b <= c:

# Same as
if a <= b and b <= c:

Counting occurrences

Python has a built-in function count on strings. It takes an string as parameter and it will return the number of occurrences of that string.

s = 'aabbccaabb'
count = s.count('a')
# count: 4

Character position in string

s = 'aabcd'
index = 2
char = s[index]
# char: b

Advent of code: 2020 Day 01

Christopher Nilsson — Tue, 01 Dec 2020 07:08:46 +0000

SPOILER ALERT
This is a post with my solutions and learnings from the puzzle. Don't continue reading if you haven't tried the puzzle on your own yet.

If you want to do the puzzle, visit adventofcode.com.

Key learnings

For-loops
If statements

You need to understand loops and if-statements to solve the puzzle. You can make it more advanced by optimizing the solution, then there are some more key learnings. Though the input is small enough that no optimization is needed.

Puzzle part 1

You get a list of numbers and the puzzle is: Find the two entries that sum to 2020; what do you get if you multiply them together?.

Input example

The input is a file with numbers. They are in the format of one number per line.

Parse input

Start by preparing how to parse the data. My programming language of choice is python:

# Open the input file
inputfile = open('01.input', 'r')

# Parse lines to array of numbers
lines = inputfile.readlines()
entries = [int(x.strip()) for x in lines]

Solution - O(N^2)

A first assumption is made that 1010 isn't on the entry-list. Therefore it doesn't matter if we happen to compare a entry to itself. Otherwise it would give a false positive.

The naive solution is a double for-loop where we check all possible combinations of two entries. For those entries we check if they sum up to 2020, if so it returns the multiplication of them.

In worst case it requires O(N^2). The input-file is 200 lines long, which means 200 * 200 = 40 000 comparisons. It executes within a few seconds on my computer.

def part1(entries):
  for x in entries:
    for y in entries:
      if x + y == 2020:
        return x * y
result = part1(entries)
print("Result part 1: %d" % result)

Solution advanced - O(N)

If we use a set to store the rests we can optimize the solution to O(N) in time complexity. The rest is the difference between our current entry X and 2020

X + rest = 2020 ==> rest = 2020 - X

For each entry X we check if we have a value in the rests-set which fulfills X + rest == 2020. Otherwise we store X as a rest.

def part1(entries):
    rests = set()

    for x in entries:
        rest = 2020 - x
        if rest in rests:
            return rest * x
        else:
            rests.add(x)

Part 2

The second part of the puzzle is: what is the product of the three entries that sum to 2020?

Solution - O(N^3)

A naive solution is just to add another for loop. This gives us 3 for-loops that in worst case gives time complexity of O(N^3)

def part2(entries):
    for x in entries:
        for y in entries:
            for z in entries:
                if x + y + z == 2020:
                    return x * y * z

Solution - O(N^2)

A more optimized solution is to calculate this in two steps. First using a dictionary to store each possible combination of two entries. This takes O(N^2) time. Then we iterate through the list once again to find the third entry required to meet 2020.

The dictionary has the sum of two entries as key, and multiplication of them as the value.

This solution has time complexity of O(N^2 + N) which is simplified to O(N^2)

def part2(entries):
    rests = {}
    for x in entries:
        for y in entries:
            rests[x + y] = x * y

    for x in entries:
        rest = 2020 - x
        if rest in rests:
            return x * rests[rest]

Please share if you know a faster way of solving this problem!

Other tricks

Another way to increase performance is to never look at a combination twice. Not sure which time complexity it gives. At least better than O(N^2) and O(N^3) for part 1 and part 2 respectively. Please comment below if you know!

def part1(entries):
  size = len(entries)
  for i in range(size):
      for j in range(i + 1, size):
          if entries[i] + entries[j] == 2020:
            return entries[i] * entries[j]

def part2(entries):
  size = len(entries)
  for i in range(size):
    for j in range(i + 1, size):
      for k in range(j + 1, size):
        if entries[i] + entries[j] + entries[k] == 2020:
          return entries[i] * entries[j] * entries[k]

Functional style

Some entertainment for the ones that prefer a more functional style of coding. The solutions generates all pairs that sum up to 2020, and then filters on which pair that is present in the list.

def part1functional(arr):
    return [
        a * b
        for (a,b)
        in filter(
            lambda (a,b): a in arr and b in arr,
            zip(range(0, 1010, 1), range(2020, 1010, -1))
        )
    ][0]

New git-version released! 🎉

Christopher Nilsson — Thu, 22 Oct 2020 12:24:20 +0000

Git 2.29 is released: https://github.blog/2020-10-19-git-2-29-released/

One thing that I learned reading through the release was that git has shortlog command. It is similar to git log, but will group the commits to authors.

Example:

$> git shortlog
Aaron Lipman (12):
      t6030: modernize "git bisect run" tests
      rev-list: allow bisect and first-parent flags
      cmd_bisect__helper: defer parsing no-checkout flag
      [...]

Adrian Moennich (1):
      ci: fix inconsistent indentation

Alban Gruin (1):
      t6300: fix issues related to %(contents:size)

[...]

Upgrading git on mac

https://ajahne.github.io/blog/tools/2018/06/11/how-to-upgrade-git-mac.html

DEV Community: Christopher Nilsson

Advent of Code: 2020 Day 09 solutions

TOC

Key learning

Puzzle

Part 1

Parsing input

Solution (bad)

Solution (good)

Solution (optimized)

Part 2

Solution

Thanks for reading!

Advent of Code: 2020 Day 08

Key learning

Puzzle

Part 1

Parsing input

Solution: Quick

Solution: Extendable

Part 2

Solution

Thanks for reading!

Advent of Code: 2020 Day 07

TOC

Key learning

Puzzle

Part 1

Parsing input

Solution: Breadth first

Solution: Depth first

Part 2

Parsing input

Solution

Alternative: With regex

Alternative: Network X

More python tools

Thanks for reading!

AoC: 2020 Day 06 AWK

AWK

Prerequisite understandings

Solution

Good reads about AWK

Advent of Code: 2020 Day 06

TOC

Key learning

Puzzle

Part 1

Part 2

Alternative solution

Set operations

Functional style

Python tricks

Thanks for reading!

Advent of Code: 2020 Day 05

Key learning

Puzzle

Part 1

Part 2

Alternative solutions

Python tips

Transform dictionaries

"".join(list)

int('10101010', 2)

max(arr)

Thanks for reading!

Advent of Code: 2020 Day 04

Key learnings

Puzzle

Part 1

Parse input

Solution

Part 2

My Solution

Comments

Thanks for reading!

Advent of code: 2020 Day 03

Key learnings

Puzzle

Part 1