# Patrick Wang

## Part 1

In Day 6, we are told to look at answers to a 26-yes-or-no-question form. Each of these questions is represented by a letter from a to z. If we consider the following input:

abcx
abcy
abcz


We have a group of three answers to the form, and in total, six questions were answered with a “yes”: a, b, c. x, y, and z.

Groups of answers are separated by a white line. So for example, we have two groups of answers illustrated just below:

a

a
b
c


The objective of Part 1 is to compute the sum of questions answered with a “yes” in each group.

When we need unicity (as stated in this day’s example), a good intuition is to usually think of sets. Indeed, sets can assure us that each element in a set is present there only once. So, our problem now is to correctly parse the input data and to create sets for each group of answers. Here, two difficulties:

• Some lines can have multiple letters which need to be splitted before being added to the set (indeed, abc is different from a, b, and c).
• We need to make sure that white lines are handled correctly, i.e., they mark the end of a set and the beginning of another one.

And finally, we need to count the numbers of questions answered with a “yes”. This can be done with a simple count variable that is incremented by the length of each set we are creating. And so, our answer can look like this:

count = 0
for line in lines:
letters = set()
if not line:
count += len(letters)
letters.clear()
else:
for letter in line:
count += len(letters)   # We don't forget to add the length of the last group because
# there is no white line separation at the end of the file
print(count)


## Part 2

Part 2 is very similar to Part 1, except that we now have to take into account only questions that were answered with a “yes” by everyone in the group. So, if we took the example below:

abc

a
b
c

ab
ac

a
a
a
a

b


The expected output would be 6 because:

• There’s only one person in the first group, so “everyone” in the group answered 3 questions;
• In group 2, there is no question answered in common by all the group members;
• In group 3, only question a is in common between both group members;
• In group 4, same as group 3;
• In group 5, same as group 1.

The formulation of Part 2 has us rethink the way we represent the data. Indeed, we now have to more explicitely look at groups. One thing that we can observe is that because a question has to be answered “yes” by each member of a group, said question appears exactly that amount of times. And so, we can represent our data with a list of tuples, where each tuple would contain the group size and all the letters as a single string.

groups = []
group_size = 0
for line in lines:
if not line:
# We add the tuple to the group, then reinitialise all the values
group_size = 0
else:
group_size += 1
# Once again, we don't forget to add the last group


Now that we have the groups, we can apply what was described above. One question remains though: How do we know which letters to look for? My proposition is to look at the first letter, count its number of occurrences, and then remove it with replace(). That should give something like this:

count = 0