Advent of Code: Day 4

This is a very short post in my collection working through this year’s Advent of Code challenges. Unlike the previous ones, this has no mathematical comments, as it was a very short exercise. This notebook is available in its original format on my github.

Day 4: High Entropy Passphrases

Given a list of strings, determine how many strings have no duplicate words.

This is a classic problem, and it’s particularly easy to solve this in python. Some might use collections.Counter, but I think it’s more straightforward to use sets.

The key idea is that the set of words in a sentence will not include duplicates. So if taking the set of a sentence reduces its length, then there was a duplicate word.

In [1]:
with open("input.txt", "r") as f:
    lines = f.readlines()
def count_lines_with_unique_words(lines):
    num_pass = 0
    for line in lines:
        s = line.split()
        if len(s) == len(set(s)):
            num_pass += 1
    return num_pass


I think this is the first day where I would have had a shot at the leaderboard if I’d been gunning for it.

Part 2

Let’s add in another constraint. Determine how many strings have no duplicate words, even after anagramming. Thus the string

abc bac

is not valid, since the second word is an anagram of the first. There are many ways to tackle this as well, but I will handle anagrams by sorting the letters in each word first, and then running the bit from part 1 to identify repeated words.

In [2]:
with open("input.txt", "r") as f:
    lines = f.readlines()
sorted_lines = []
for line in lines:
    sorted_line = ' '.join([''.join(l) for l in map(sorted, line.split())])

['bddjjow acimrv bcjjm anr flmmos fiosv',
 'bcmnoxy dfinyzz dgmp dfgioy hinrrv eeklpuu adgpw kqv']
In [3]:
This entry was posted in Expository, Programming, Python and tagged , , . Bookmark the permalink.

One Response to Advent of Code: Day 4

  1. I got an alternative idea for part 2 which I would like to share:
    – loop through the lines
    – create an empty set S
    – loop through the words
    – create a dictionary D for each word which counts the repetitions of each letter.
    – check if the set S contains the dictionary D, if not add it to S, if yes skip to the next line
    – if you always add the new D to S then you got a line without anagrams, time to refresh the counter!

    I would say this should be faster because creating the dictionary has a lower complexity than ordering the letters in the word. Moreover as soon we get an anagram we skip to the next line, avoiding useless processing of the remaining words!

    Nice challenge by the way! I wasn’t aware of it, thanks for spreading the word!

Leave a Reply