Advent of Code: 2020 Day 06
Tags: adventofcode, python
Published: 2020-12-06 08:29:48


⚠️ **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](https://adventofcode.com/2020/day/6).

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

## TOC
* [Key learning](#key-learning)
* [Puzzle](#puzzle)
* [Part 1](#part-1)
* [Part 2](#part-2)
* [Alternative solutions](#alternative-solution)
* [Python tricks](#python-tricks)

## Key learning <a name="key-learning"></a>

* Sets and dictionaries

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

## Puzzle <a name="puzzle"></a>

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 <a name="part-1"></a>

> 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.

```python
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.

```python
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 <a name="part-2"></a>

> 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.

```python
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 <a name="alternative-solution"></a>

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:

```python
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](https://docs.python.org/3/library/collections.html#collections.Counter)


### Set operations

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

```python
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.

```python
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 <a name="python-tricks"></a>

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:

```python
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:

```python
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](https://github.com/cNille/AdventOfCode/blob/master/2020/06.py)