Advent-of-Code on ¬ just serendipity 🍀

Advents

serendipity@perrotta.dev (Thiago Perrotta) — Fri, 27 Dec 2024 20:36:42 -0300

♠ Too many advents:

Advent of Code: my favorite. See coding.
Advent of Papers
Debug December
HTMLHell Advent Calendar

Surely you will never run out of daily technical challenges to do in December!

And don’t forget about the likes of Wordly.

— § —

Reply via email

#advent-of-code #dev

Advent of Code 2024: Day 17

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 25 Dec 2024 16:13:30 -0300

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #17 puzzle.

It’s a simulation problem, a quite delightful one to implement.

Using python data classes would have been natural, but I went full imperative in this one.

Part 2 would require clever backwards computation, and I wasn’t interested in doing so. I liked the approach from Todd Ginsberg.

The full solution:

#!/usr/bin/env python3
import sys

def main():
    with open(sys.argv[1]) as input:
        lines = input.read().splitlines()

    a, b, c = [int(line.split()[2]) for line in lines[0:3]]
    program = [int(op) for op in lines[4].split()[1].split(",")]
    ip = 0
    stdout = []

    def combo(operand):
        assert 0 <= operand < 7

        if 0 <= operand <= 3:
            return operand
        elif operand == 4:
            return a
        elif operand == 5:
            return b
        elif operand == 6:
            return c

    while ip < len(program) - 1:
        opcode = program[ip]
        operand = program[ip + 1]

        # adv, division
        if opcode == 0:
            numerator = a
            denominator = 2 ** combo(operand)
            a = numerator // denominator
        # bxl, bitwise xor
        elif opcode == 1:
            b ^= operand
        # bst, modulo
        elif opcode == 2:
            b = combo(operand) % 8
        # jnz
        elif opcode == 3:
            if a != 0:
                ip = operand
                continue
        # bxc, bitwise xor
        elif opcode == 4:
            b ^= c
        # out
        elif opcode == 5:
            stdout.append(combo(operand) % 8)
        # bdv
        elif opcode == 6:
            numerator = a
            denominator = 2 ** combo(operand)
            b = numerator // denominator
        # cdv
        elif opcode == 7:
            numerator = a
            denominator = 2 ** combo(operand)
            c = numerator // denominator

        ip += 2

    # part one
    print(",".join(map(str, stdout)))

if __name__ == '__main__':
    main()

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2024: Day 9

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 25 Dec 2024 16:09:53 -0300

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #9 puzzle.

A disk fragmentation problem.

It’s mostly an ad-hoc problem, there isn’t much commentary to make.

Part two was quite annoying so I simply skipped it.

The full solution:

#!/usr/bin/env python3
import sys

def expand(disk: list[int]) -> str:
    output = []
    fill = True
    d = 0

    for n in disk:
        if fill:
            output += [str(s) for s in n * [d]]
            d += 1
        else:
            output += n * '.'
        fill = not fill

    return output

def defrag(disk: str) -> str:
    p = expand(disk)

    left = 0
    right = len(p) - 1

    while left < right:
        if p[left] == '.':
            p[left], p[right] = p[right], p[left]
            right -= 1
            while p[right] == '.' and left < right:
                right -= 1

        left += 1

    return p

def checksum(disk):
    total = 0

    for i, d in enumerate(disk):
        if d == '.':
            break
        total += i * int(d)

    return total

def main():
    with open(sys.argv[1]) as input:
        lines = input.read().splitlines()

    disk = [int(x) for x in lines[0]]

    # part one
    print(checksum(defrag(disk)))

if __name__ == '__main__':
    main()

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2024: Day 8

serendipity@perrotta.dev (Thiago Perrotta) — Fri, 20 Dec 2024 22:47:51 -0300

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #8 puzzle.

This is a problem in a 2D grid. I like to start by making a frequency map (dictionary) from the frequencies to the coordinates where they occur:

from collections import defaultdict

# {'0': ((1,8), ...)}
freq_map = defaultdict(tuple)
for x, line in enumerate(lines):
    for y, field in enumerate(line):
        if field.isalnum():
            freq_map[field] += ((x, y),)

Then it’s just a matter of going through every coordinate pair for a given frequency. combinations() from itertools is great for that:

from itertools import combinations

antinodes = set()

for all_coords in freq_map.values():
    for coord1, coord2 in combinations(all_coords, 2):
        antinodes.update(compute_antinodes(coord1, coord2, len(lines), len(lines[0])))

The meat of the code lives in compute_antinodes. We need to compute two coordinates and check whether they are within bounds:

def within_bounds(x, y, height, width):
    return 0 <= x < height and 0 <= y < width

def compute_antinodes(coord1, coord2, height, width):
    x1, y1 = coord1
    x2, y2 = coord2

    dx = x2 - x1
    assert dx >= 0

    dy = y2 - y1

    antinodes = ()

    for (x0, y0, direction) in ((x1, y1, -1), (x2, y2, +1)):
        x, y = x0 + direction * dx, y0 + direction * dy
        if within_bounds(x, y, height, width):
            antinodes += ((x, y),)

    return antinodes

The assertion gives us peace of mind.

The answer is the number of antinodes.

For part two, we need to extend the compute_antinodes logic to keep going until it gets out-of-bounds:

def compute_antinodes(coord1, coord2, height, width, unbounded=False):
    x1, y1 = coord1
    x2, y2 = coord2

    dx = x2 - x1
    assert dx >= 0

    dy = y2 - y1

    if unbounded:
        antinodes = ((x1, y1), (x2, y2))
    else:
        antinodes = ()

    for (x0, y0, direction) in ((x1, y1, -1), (x2, y2, +1)):
        steps = 1
        while True:
            x, y = x0 + direction * steps * dx, y0 + direction * steps * dy
            if within_bounds(x, y, height, width):
                antinodes += ((x, y),)
                steps += 1
            else:
                break

    return antinodes

The full solution:

#!/usr/bin/env python3
from collections import defaultdict
from itertools import combinations

import sys

def within_bounds(x, y, height, width):
    return 0 <= x < height and 0 <= y < width

def compute_antinodes(coord1, coord2, height, width, unbounded=False):
    x1, y1 = coord1
    x2, y2 = coord2

    dx = x2 - x1
    assert dx >= 0

    dy = y2 - y1

    if unbounded:
        antinodes = ((x1, y1), (x2, y2))
    else:
        antinodes = ()

    for (x0, y0, direction) in ((x1, y1, -1), (x2, y2, +1)):
        steps = 1
        while True:
            x, y = x0 + direction * steps * dx, y0 + direction * steps * dy
            if within_bounds(x, y, height, width):
                antinodes += ((x, y),)
                steps += 1
            else:
                break

    return antinodes

def main():
    with open(sys.argv[1]) as input:
        lines = input.read().splitlines()

    # {'0': ((1,8), ...)}
    freq_map = defaultdict(tuple)
    for x, line in enumerate(lines):
        for y, field in enumerate(line):
            if field.isalnum():
                freq_map[field] += ((x, y),)

    antinodes = set()

    for all_coords in freq_map.values():
        for coord1, coord2 in combinations(all_coords, 2):
            antinodes.update(compute_antinodes(coord1, coord2, len(lines), len(lines[0])))

    # part one
    print(len(antinodes))

    antinodes = set()

    for all_coords in freq_map.values():
        for coord1, coord2 in combinations(all_coords, 2):
            antinodes.update(compute_antinodes(coord1, coord2, len(lines), len(lines[0]), unbounded=True))

    # part two
    print(len(antinodes))

if __name__ == '__main__':
    main()

Instead of using tuples or coordinates all over the place, we could simply have modified the map inplace, and then iterated over it in the end to count the antinodes. I like the tuple abstraction better, and it’s quite efficient anyway.

— § —

Reply via email

#advent-of-code #dev %coding

★ Just

serendipity@perrotta.dev (Thiago Perrotta) — Fri, 13 Dec 2024 01:16:41 -0300

♠ Just is a command runner, a modern replacement for GNU Make.

It is written in Rust, has sensible defaults, and lots of syntactic sugar. A good analogy is fish versus bash when comparing just to make.

It’s very easy to learn from its README.md alone as it’s quite comprehensive. There’s also a gitbook.

Simon Willison prompted me to try it out.

As an exercise I decided to convert the Makefile used to manage this blog into a Justfile.

The original Makefile:

# Sitemap URL
SITEMAP = https://perrotta.dev/sitemap.xml

# Hugo port
PORT := 1313

# Abort if hugo is not installed.
ifeq (, $(shell which hugo))
  $(error "No hugo in $$PATH, install it first")
endif

all:
	hugo server --bind="0.0.0.0" --buildDrafts --port $(PORT) --watch

build:
	hugo --environment production --gc --minify

clean:
	$(RM) -r public/ resources/

ping:
	# Ping Google about changes in the sitemap
	curl -sS -o /dev/null "https://www.google.com/ping?sitemap=$(SITEMAP)"
	# Ping Bing (DuckDuckGo, etc) about changes in the sitemap
	curl -sS -o /dev/null "https://www.bing.com/ping?sitemap=$(SITEMAP)"

.PHONY: all build clean ping

Initially I asked ChatGPT to convert it to a Justfile but it was a disaster, even after a couple of iterations. Then I did it myself¹. The Justfile:

set dotenv-load

watch:
	hugo server --buildDrafts --port ${PORT:-1313} --watch

build:
	hugo --environment production --gc --minify

# Create a new post. Usage: `just new "advent of code day 8"`
new post:
	hugo new content/posts/`date "+%Y-%m-%d"`-{{ kebabcase(post) }}.md

clean:
	rm -rf public/ resources/

# Ping Google and Bing about changes in the sitemap
ping sitemap="https://perrotta.dev/sitemap.xml":
	curl -sS -o /dev/null "https://www.google.com/ping?sitemap={{ sitemap }}"
	curl -sS -o /dev/null "https://www.bing.com/ping?sitemap={{ sitemap }}"

The main differences:

Environment variables: use {{ foo }} instead of $(FOO)
Exception: environment variables loaded from .env (via set dotenv-load) use $FOO or ${FOO} instead, like POSIX shell variables
Use rm -rf instead of $(RM) -r
Rules accept parameters. Look at new post as an example. Example usage: just new "advent of code day 8"
Run shell commands within rules with backticks. $(cmd) does not work.
Some handy out-of-the-box functions such as kebabcase(). No need to implement this kind of string manipulation in plain shell script!
Documentation comments above rules are recognized. They are displayed as help / usage text when running just -l. No need for hacky self-documented Makefile setups!

% just -l
Available recipes:
    build
    clean
    new post # Create a new post. Usage: `just new "advent of code day 8"`
    ping sitemap="https://perrotta.dev/sitemap.xml" # Ping Google and Bing about changes in the sitemap
    watch

With a bit of LLM prompting in lieu of Google or Stack Overflow searches. ↩︎

— § —

Reply via email

#advent-of-code #bestof #dev

Advent of Code 2024: Day 7

serendipity@perrotta.dev (Thiago Perrotta) — Thu, 12 Dec 2024 23:12:31 -0300

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #7 puzzle.

Part one: dynamic programming!

def calibrate_one(test_value, operands):

    @lru_cache(maxsize=None)
    def dp_calibrate(acc, index):
        if acc == test_value and index == len(operands):
            return True

        if acc > test_value or index == len(operands):
            return False

        return dp_calibrate(acc + operands[index], index + 1) or dp_calibrate(acc * operands[index], index + 1)

    return dp_calibrate(operands[0], 1)

I learned this style from NeetCode. An inner function to drive the memoization alongside lru_cache. Beautiful!

In my initial solution I passed the whole operands tuple as the second argument. Later on I changed it to pass the current index in the tuple, which is simpler.

Part two is a natural extension of part one, with an extra operator:

def calibrate_two(test_value, operands):

    @lru_cache(maxsize=None)
    def dp_calibrate(acc, index):
        if index == len(operands):
            return acc == test_value

        if acc > test_value:
            return False

        return dp_calibrate(acc + operands[index], index + 1) or dp_calibrate(acc * operands[index], index + 1) or dp_calibrate(int(str(acc) + str(operands[index])), index + 1)

    return dp_calibrate(operands[0], 1)

The full solution:

#!/usr/bin/env python3
import sys
from functools import lru_cache

def calibrate_one(test_value, operands):

    @lru_cache(maxsize=None)
    def dp_calibrate(acc, index):
        if acc == test_value and index == len(operands):
            return True

        if acc > test_value or index == len(operands):
            return False

        return dp_calibrate(acc + operands[index], index + 1) or dp_calibrate(acc * operands[index], index + 1)

    return dp_calibrate(operands[0], 1)

def calibrate_two(test_value, operands):

    @lru_cache(maxsize=None)
    def dp_calibrate(acc, index):
        if index == len(operands):
            return acc == test_value

        if acc > test_value:
            return False

        return dp_calibrate(acc + operands[index], index + 1) or dp_calibrate(acc * operands[index], index + 1) or dp_calibrate(int(str(acc) + str(operands[index])), index + 1)

    return dp_calibrate(operands[0], 1)

def main():
    with open(sys.argv[1]) as input:
        lines = input.read().splitlines()

    total_one = total_two = 0

    for line in lines:
        test_value, operands = line.split(':')
        test_value = int(test_value)
        operands = [int(x) for x in operands.split()]

        if calibrate_one(test_value, operands):
            total_one += test_value

        if calibrate_two(test_value, operands):
            total_two += test_value

    # part one
    print(total_one)

    # part two
    print(total_two)

if __name__ == '__main__':
    main()

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code: discussion group

serendipity@perrotta.dev (Thiago Perrotta) — Thu, 12 Dec 2024 19:30:53 -0300

♠ Assuming you are following this year’s advent of code, you are welcome to join our Telegram discussion group¹. It is a supergroup, one of its channels is #adventofcode.

It’s a moderated group, and this invitation link will expire within 2 weeks of the time of this post. ↩︎

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2024: Day 11

serendipity@perrotta.dev (Thiago Perrotta) — Thu, 12 Dec 2024 19:15:35 -0300

♠ Link to Day #11 puzzle.

Part one can be done with a simulation.

It is very delightful to do it in python: lists are quite flexible, and converting from integers to strings and vice-versa is seamless. Counting the number of digits of x is just a matter of len(str(x)). In C++ it’s a bit kludgier with std::string(x).size() and std::stoi(s), but then you need to remember which header to import¹.

I thought of using reduce to do blink(blink(stone))... and so on:

print(len(reduce(lambda stone: blink(stone), range(25), stones)))

…nonetheless it’s more readable to simply use a plain for-range loop:

for _ in range(25):
    stones = blink(stones)
print(len(stones))

The secret sauce is in blink:

def blink(stones):
    stones_next = []

    for stone in stones:
        s = str(stone)

        if stone == 0:
            stones_next.append(1)

        elif len(s) % 2 == 0:
            index = len(s) // 2
            stones_next.append(int(s[:index]))
            stones_next.append(int(s[index:]))

        else:
            stones_next.append(stone * 2024)

    return stones_next

For part two we need to be cleverer. In principle the same approach would work, however it takes too long to process due to its exponential nature. In my laptop I can get up to the 42nd blink iteration without losing my patience to wait even longer.

The main observation to account for is that we only care about the length of the stone sequence, hence the original task transforms into a simple 2D dynamic programming problem.

I call:

print(dp_blink(stones, 75))

Which is defined this way:

def dp_blink(stones, times):
    from functools import lru_cache

    @lru_cache(maxsize=None)
    def dp(stone: int, times: int) -> int:
        if times == 0:
            return 1

        return sum([dp(stone, times - 1) for stone in blink([stone])])

    return sum([dp(stone, times) for stone in stones])

The DP consists of the stone, and how many times are left for you to blink at it.

The full solution:

#!/usr/bin/env python3
import sys

def blink(stones):
    stones_next = []

    for stone in stones:
        s = str(stone)

        if stone == 0:
            stones_next.append(1)

        elif len(s) % 2 == 0:
            index = len(s) // 2
            stones_next.append(int(s[:index]))
            stones_next.append(int(s[index:]))

        else:
            stones_next.append(stone * 2024)

    return stones_next

def dp_blink(stones, times):
    from functools import lru_cache

    @lru_cache(maxsize=None)
    def dp(stone: int, times: int) -> int:
        if times == 0:
            return 1

        return sum([dp(stone, times - 1) for stone in blink([stone])])

    return sum([dp(stone, times) for stone in stones])

def main():
    with open(sys.argv[1]) as input:
        lines = input.read().splitlines()

    stones = [int(stone) for stone in lines[0].split()]

    for _ in range(25):
        stones = blink(stones)

    # part one
    print(len(stones))

    # This is very slow, with an exponential complexity runtime.
    # What did you expect?
    #
    # for i in range(50):  # 50 = 75 - 25
    #     print(i)
    #     stones = blink(stones)

    # # part two
    # print(len(stones))

    stones = [int(stone) for stone in lines[0].split()]

    # part two
    print(dp_blink(stones, 75))

if __name__ == '__main__':
    main()

It’s #include <string>. ↩︎

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2024: Day 6

serendipity@perrotta.dev (Thiago Perrotta) — Thu, 12 Dec 2024 15:26:35 -0300

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #6 puzzle.

Part one is a classic 2D matrix (graph) traversal problem.

To store state I created a visited set with the (x, y) coordinates. Alternatively I could have changed the input inplace, but I didn’t want to deal with the immutability of python strings, i.e. given:

l = ["....."]

…you can’t simply do l[0][0] = 'X', because python strings are immutable. We could define a new string and assign it to l[0], or we could change the input to:

l = ['.', '.', '.', '.', '.']

…so that replacing characters becomes trivial.

The full solution:

#!/usr/bin/env python3
import sys

def find(lines, c):
    for i, line in enumerate(lines):
        if c in line:
            return i, line.index(c)
    raise ValueError(f'Could not find {c} in lines')

def move(pos, dir, lines, visited):
    dirs_clockwise = ((1, 0), (0, -1), (-1, 0), (0, 1))

    while True:
        next_pos = pos[0] + dir[0], pos[1] + dir[1]

        if next_pos[0] < 0 or next_pos[0] >= len(lines) or next_pos[1] < 0 or next_pos[1] >= len(lines[0]):
            break

        if lines[next_pos[0]][next_pos[1]] in '.^':
            pos = next_pos
            visited.add(pos)
        elif lines[next_pos[0]][next_pos[1]] == '#':
            dir = dirs_clockwise[(dirs_clockwise.index(dir) + 1) % 4]

def main():
    with open(sys.argv[1]) as input:
        lines = input.read().splitlines()

    pos = find(lines, '^')
    dir = (-1, 0)  # up

    visited = set((pos,))

    move(pos, dir, lines, visited)

    # part one
    print(len(visited))

if __name__ == '__main__':
    main()

I did not solve part two yet. I know how to do it, but my initial approach is too brute force to my taste. Perhaps I’ll come up with something clever later on.

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2024: Day 5

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 08 Dec 2024 23:24:27 +0100

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #5 puzzle.

It is a topological sort problem, plain and simple.

In part one all we care about is whether certain input sequences are valid, within the sort constraints. It’s very straightforward to verify that by exhaustively checking all constraints (“edges”):

import sys

def is_correct(update, edges):
    position = defaultdict(lambda: sys.maxsize, {node: i for (i, node) in enumerate(update)})

    for (first, second) in edges:
        if first in update and second in update and position[first] > position[second]:
            return False
    return True

position is a dictionary representing in which index (position) each element occurs. I make use of a defaultdict with a very large value set by default (instead of a vanilla dict) to avoid the need to explicitly check for element presence.

In part two we need to perform the actual topological sort. Or…do we? Doing toposort would be the most efficient way to resolve it, however, in this case, plain brute force is good enough:

def toposort(update, edges):
    position = defaultdict(lambda: sys.maxsize, {node: i for (i, node) in enumerate(update)})

    change = True
    while change:
        change = False
        for (first, second) in edges:
            if first in update and second in update and position[first] >= position[second]:
                position[first] = position[second] - 1
                change = True

    return sorted(update, key=lambda x: position[x])

Once again, we iterate through all the input constraints until we find a violation. Whenever we find one, we fix the position of the element in the wrong order by updating it to occur before the other element. We repeat this procedure until there are no more violations.

The full source:

#!/usr/bin/env python3
from collections import defaultdict
import sys

def is_correct(update, edges):
    position = defaultdict(lambda: sys.maxsize, {node: i for (i, node) in enumerate(update)})

    for (first, second) in edges:
        if first in update and second in update and position[first] > position[second]:
            return False
    return True

def toposort(update, edges):
    position = defaultdict(lambda: sys.maxsize, {node: i for (i, node) in enumerate(update)})

    change = True
    while change:
        change = False
        for (first, second) in edges:
            if first in update and second in update and position[first] >= position[second]:
                position[first] = position[second] - 1
                change = True

    return sorted(update, key=lambda x: position[x])

def main():
    with open(sys.argv[1]) as input:
        lines = input.read().splitlines()

    edges = []
    updates = []

    for line in lines:
        if "|" in line:
            edges.append(list(map(int, line.split("|"))))
        elif len(line) == 0:
            continue
        else:
            updates.append(list(map(int, line.split(","))))

    total_one = total_two = 0
    for update in updates:
        if is_correct(update, edges):
            total_one += update[len(update) // 2]
        else:
            sorted_update = toposort(update, edges)
            total_two += sorted_update[len(sorted_update) // 2]

    # part one
    print(total_one)

    # part two
    print(total_two)

if __name__ == '__main__':
    main()

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2024: Day 4

serendipity@perrotta.dev (Thiago Perrotta) — Fri, 06 Dec 2024 11:44:39 +0100

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #4 puzzle.

It’s a pretty typical 2D matrix search problem, or a graph search problem, if you will.

The problem is naturally unraveled into the following searches:

horizontally
horizontally, reversed
vertically
vertically, reversed
diagonally, all 4 directions (NW, NE, SW, SE)

It’s possible to write a single pair of for loops that addresses the general case. The (classic) idea is to think of all 8 compass directions to move along the matrix:

(1, 0)
(-1, 0)
(0, 1)
(0, -1)
(1, 1)
(-1, -1)
(-1, 1)
(1, -1)

Within the inner iteration, change x += dx and y += dy (or i += di, j += dj, naming is hard). I did this many times in C++ though, and I want to write elegant Python code.

Therefore I came up with the following solution instead, with nested list comprehensions:

def search_horizontal(matrix, keyword):
    return sum((True for row in matrix for i in range(len(row) - len(keyword) + 1) if "".join(row[i:i + len(keyword)]) in [keyword, keyword[::-1]]))

It follows the same principle as the original intent, however it leverages list slices so that we can omit the dx/dy step.

The vertical search is pretty straightforward: it is just a matter of running the horizontal search in the transposed matrix (zip(*matrix)).

I must confess that using zip to transpose matrices always felt magical and a mere coincidence that it just works™. Ruby has a .transpose method, which is more readable.

For the diagonal search, I couldn’t think of an elegant list comprehension manner to address it. Is it even possible to “2D slice” in Python?

After-the-fact I decided to ask ChatGPT, and it is indeed possible, but it requires NumPy:

If a is 2-D, returns the diagonal of a with the given offset, i.e., the collection of elements of the form a[i, i+offset]. If a has more than two dimensions, then the axes specified by axis1 and axis2 are used to determine the 2-D sub-array whose diagonal is returned. The shape of the resulting array can be determined by removing axis1 and axis2 and appending an index to the right equal to the size of the resulting diagonals.

The method call resembles numpy.array([[1, 2], [3, 4]]).diagonal(offset=1), perhaps with the aid of .flip() to account for the other direction.

Anyway, my plain diagonal search is:

def search_diagonal(matrix, keyword):
    rows = len(matrix)
    cols = len(matrix[0])

    count = 0

    for i in range(rows):
        for j in range(cols):
            if i + len(keyword) <= rows and j + len(keyword) <= cols:
                if "".join(matrix[i + k][j + k] for k in range(len(keyword))) in [keyword, keyword[::-1]]:
                    count += 1
            if i + len(keyword) <= rows and j - len(keyword) >= -1:
                if "".join(matrix[i + k][j - k] for k in range(len(keyword))) in [keyword, keyword[::-1]]:
                    count += 1

    return count

Part two is fundamentally a different problem.

One way to address it is to search for all 'A' characters, and then look around its “edges” to see if they contain exactly two 'M' and two 'S', and that they are properly arranged:

def search_double_mas(matrix):
    rows = len(matrix)
    cols = len(matrix[0])

    count = 0

    for i in range(1, rows - 1):
        for j in range(1, cols - 1):
            if matrix[i][j] != 'A':
                continue

            # look at a QWERTY keyboard to make sense of these variable names
            q = matrix[i - 1][j - 1]
            e = matrix[i - 1][j + 1]
            z = matrix[i + 1][j - 1]
            c = matrix[i + 1][j + 1]
            edges = [q, e, z, c]

            if edges.count('M') != 2 or edges.count('S') != 2:
                continue

            if q == e or q == z:
                count += 1

    return count

I couldn’t find an opportunity for reuse of the solution from part one.

The full solution:

#!/usr/bin/env python3
import sys

def search_horizontal(matrix, keyword):
    return sum((True for row in matrix for i in range(len(row) - len(keyword) + 1) if "".join(row[i:i + len(keyword)]) in [keyword, keyword[::-1]]))

def search_vertical(matrix, keyword):
    return search_horizontal(zip(*matrix), keyword)

def search_diagonal(matrix, keyword):
    rows = len(matrix)
    cols = len(matrix[0])

    count = 0

    for i in range(rows):
        for j in range(cols):
            if i + len(keyword) <= rows and j + len(keyword) <= cols:
                if "".join(matrix[i + k][j + k] for k in range(len(keyword))) in [keyword, keyword[::-1]]:
                    count += 1
            if i + len(keyword) <= rows and j - len(keyword) >= -1:
                if "".join(matrix[i + k][j - k] for k in range(len(keyword))) in [keyword, keyword[::-1]]:
                    count += 1

    return count

def search_double_mas(matrix):
    rows = len(matrix)
    cols = len(matrix[0])

    count = 0

    for i in range(1, rows - 1):
        for j in range(1, cols - 1):
            if matrix[i][j] != 'A':
                continue

            # look at a QWERTY keyboard to make sense of these variable names
            q = matrix[i - 1][j - 1]
            e = matrix[i - 1][j + 1]
            z = matrix[i + 1][j - 1]
            c = matrix[i + 1][j + 1]
            edges = [q, e, z, c]

            if edges.count('M') != 2 or edges.count('S') != 2:
                continue

            if q == e or q == z:
                count += 1

    return count

def main():
    with open(sys.argv[1]) as input:
        lines = input.read().splitlines()

    keyword = "XMAS"

    # ['abcd', 'efgh', 'ijkl'] -> [['a', 'b', 'c', 'd'], ['e', 'f', 'g', 'h'], ['i', 'j', 'k', 'l']]
    matrix = [list(line) for line in lines]

    # part one
    print(search_horizontal(matrix, keyword) + search_vertical(matrix, keyword) + search_diagonal(matrix, keyword))

    # part two
    print(search_double_mas(matrix))

if __name__ == '__main__':
    main()

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2024: Day 3

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 03 Dec 2024 16:41:23 +0100

♠ Link to Day #3 puzzle.

It’s a pretty typical regex problem. To choose not to use regex is to endeavour in pain.

The regex for part one to extract all occurrences of mul:

r'mul\(\d+,\d+\)'

Note that with r there is no need to escape the backslashes in Python.

Later on I extract the numbers with r'\d+'.

If we really wanted we could do everything with a single regex by using capturing groups, however it would become less readable.

Once the numbers are captured, it’s just a matter of accumulating their product.

I craft and test my regex with the support of https://regex101.com/ and then follow up with the Python interpreter in my laptop.

Part two adds two more operators, which we can easily account for with an or (|).

The full solution:

#!/usr/bin/env python3
import re
import sys

def main():
    with open(sys.argv[1]) as input:
        lines = input.read().splitlines()

    prod = prod_two = 0

    for memory in lines:
        ops = re.findall(r'mul\(\d+,\d+\)', memory)

        for op in ops:
            (f1, f2) = map(int, re.findall(r'\d+', op))
            prod += f1 * f2

    # part one
    print(prod)

    enabled = True
    for memory in lines:
        ops = re.findall(r"mul\(\d+,\d+\)|do\(\)|don't\(\)", memory)

        for op in ops:
            if "don't" in op:
                enabled = False
            elif "do" in op:
                enabled = True
            elif 'mul' in op:
                (f1, f2) = map(int, re.findall(r'\d+', op))

                if enabled:
                    prod_two += f1 * f2

    # part two
    print(prod_two)

if __name__ == '__main__':
    main()

I intended to use match merely for style points however it’s only available from Python 3.10+, thus I sticked with a mere if-elif construct.

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2024: Day 2

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 03 Dec 2024 01:15:00 +0100

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #2 puzzle.

The first part is straightforward. It felt right to use pairwise to compute the differences between each adjacent pair:

diffs = [(b - a) for (a,b) in pairwise(map(int, line.split(' ')))]

Then we combine it with all:

def is_safe(diffs):
    return all(1 <= n <= 3 for n in diffs) or all(-3 <= n <= -1 for n in diffs)

Note that it is necessary to use two all expressions. It feels tempting to do:

all(1 <= n <= 3 or -3 <= n <= -1 for n in diffs)

…however that’s incorrect. For example: diffs = [1, -1, 1, -1] with an input such as [1, 2, 1, 2] would pass the test even though it shouldn’t.

It also feels tempting to use abs() but then an additional check would be necessary to ensure the diffs are either all positive or all negative.

The second part was trickier.

Initially I was doing:

list(1 <= n <= 3 for n in diffs).count(False) <= 1 or list(-3 <= n <= -1 for n in diffs).count(False) <= 1

…but then I realized I misunderstood the problem.

The 1 2 7 8 9 line, whose diff is [1, 5, 1, 1], illustrates it well: in principle it would pass the test by dropping “5” from the diff. However, that cannot be correct, because 2 -> 8 is too big of a jump.

The brute force way is to drop elements one by one, splitting the original list into two, and then checking is_safe in the merged sublists. That would require computing diffs every time, which would yield an O(n^2) solution.

We can do better by pre-computing diffs only once, and then adding a bit of manipulation to reconstruct what the merged diffs would be. The end goal is to compute this:

is_safe(diffs[:i-1] + [l[i+1] - l[i-1]] + diffs[i+1:]):

…i.e. the left part of diffs, the right part of diffs, and a rolling diff element in the middle.

The full solution:

#!/usr/bin/env python3
import sys

from itertools import pairwise

def main():
    with open(sys.argv[1]) as input:
        lines = input.read().splitlines()

    safe = 0
    safe_damp = 0

    def is_safe(diffs):
        return all(1 <= n <= 3 for n in diffs) or all(-3 <= n <= -1 for n in diffs)

    for line in lines:
        l = list(map(int, line.split(' ')))
        diffs = [(b - a) for (a,b) in pairwise(l)]

        is_this_safe = is_safe(diffs)
        if is_this_safe:
            safe += 1
            safe_damp += 1
            continue

        for i in range(len(l)):
            if i == 0:
                if is_safe(diffs[1:]):
                    safe_damp += 1
                    break
            elif i == len(l) - 1:
                if is_safe(diffs[:-1]):
                    safe_damp += 1
                    break
            else:
                if is_safe(diffs[:i-1] + [l[i+1] - l[i-1]] + diffs[i+1:]):
                    safe_damp += 1
                    break

    # part one
    print(safe)

    # part two
    print(safe_damp)

if __name__ == '__main__':
    main()

A few notes:

there’s no need for pairwise; a plain for-range loop would have done the job just fine; pairwise is stylish though
1 <= n <= 3 is syntactic sugar for 1 <= n and n <= 3. Python is sweet.
part two could become a bit more elegant by introducing another helper function
naming is hard
pairwise is only available from Python 3.10+. macOS 15 (Sequoia) ships with Python 3.9. Oh well…I needed to use the Python binary from homebrew.

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2024: Day 1

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 01 Dec 2024 22:29:19 +0100

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #1 puzzle.

This is just a warm-up.

Given two lists of integers, iterate over them and sum the absolute difference between each pair. zip + sum is the perfect pair¹ for the job.

Part two: iterate over the left list whilst accumulating how often the element appears in the right list. “How often” has, almost always, the smell of a Counter.

The full solution²:

#!/usr/bin/env python3
import sys

from collections import Counter

def main():
    with open(sys.argv[1]) as input:
        lines = input.read().splitlines()

    left = []
    right = []

    for line in lines:
        l, r = map(int, line.split())
        left.append(l)
        right.append(r)

    left.sort()
    right.sort()

    # part one
    print(sum(abs(l - r) for (l, r) in zip(left, right)))

    freqs = Counter(right)

    # part two
    print(sum(l * freqs[l] for l in left))

if __name__ == '__main__':
    main()

I’m not sure I like it, And I’m so tired of fighting ↩︎
The git repository is ever-evolving and the source of truth, whereas the blog post is a snapshot. I’ll experiment with cross-posting solutions here even though it duplicates the repository ones. ↩︎

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2023: Day 1

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 04 Dec 2023 00:00:00 +0000

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #1 puzzle.

The first part is straightforward: extract the first and last digit from each line and sum them.

Part two gets trickier: we need to handle spelled-out digits like “one”, “two”, etc. The naive approach of replacing spellings with digits fails for overlapping cases like “eightwothree” which should yield 83, not 23.

The solution: find the leftmost and rightmost match among all digit spellings and numeric digits, then combine them.

#!/usr/bin/env python3
import sys


def get_calibration_value(line: str) -> int:
    """
    Extract the first and the last digit from the string, and return a number
    composed by them, in that order.
    '1abc2' -> 12
    """
    digits = [c for c in line if c.isdigit()]
    return int(digits[0] + digits[-1])


SPELLINGS = {
    # 'zero': '0',  # not in the problem statement
    'one': '1',
    'two': '2',
    'three': '3',
    'four': '4',
    'five': '5',
    'six': '6',
    'seven': '7',
    'eight': '8',
    'nine': '9',
}


# This attempt is incorrect because of the following test case:
#   eightwothree -> eigh23 -> 23
# Whereas it should have been 83.
def get_calibration_value_with_spellings_attempt_1(line: str) -> int:
    for spelling, digit in SPELLINGS.items():
        line = line.replace(spelling, digit)

    return get_calibration_value(line)


def get_calibration_value_with_spellings(line: str) -> int:
    targets = set(list(SPELLINGS.keys()) + list(SPELLINGS.values()))

    # from the left
    indices = {}
    for target in targets:
        index = line.find(target)
        if index != -1:
            indices[target] = index

    [target_min, _] = min(list(indices.items()), key=lambda x: x[1])

    # from the right
    indices = {}
    for target in targets:
        index = line.rfind(target)
        if index != -1:
            indices[target] = index

    [target_max, _] = max(list(indices.items()), key=lambda x: x[1])

    if target_min in SPELLINGS:
        target_min = SPELLINGS[target_min]

    if target_max in SPELLINGS:
        target_max = SPELLINGS[target_max]

    return int(target_min + target_max)


def main():
    with open(sys.argv[1]) as input:
        lines = input.read().splitlines()

    # Part I
    print(sum([get_calibration_value(line) for line in lines]))

    # Part II
    print(sum([get_calibration_value_with_spellings(line) for line in lines]))


if __name__ == '__main__':
    main()

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2022: Day 10

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 12 Dec 2022 00:00:00 +0000

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #10 puzzle.

Calculate signal strength and render CRT output.

#!/usr/bin/env python3
import sys


def main():
    with open(sys.argv[1]) as input:
        lines = input.read().splitlines()

    X = 1
    cycle = 1
    cycle_to_X = {cycle: X}

    for line in lines:
        if line == 'noop':
            cycle += 1
        else:
            increment = int(line.split(' ')[1])
            X += increment
            cycle += 2
        cycle_to_X[cycle] = X

    strength = 0

    for multiple in range(20, max(cycle_to_X.keys()), 40):
        if multiple in cycle_to_X:
            strength += multiple * cycle_to_X[multiple]
        else:
            predecessor = max(
                [key for key in cycle_to_X.keys() if key < multiple])
            strength += multiple * cycle_to_X[predecessor]

    # Part 1
    print(strength)


if __name__ == '__main__':
    main()

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2022: Day 9

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 12 Dec 2022 00:00:00 +0000

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #9 puzzle.

Simulate rope physics with head and tail.

#!/usr/bin/env python3
import sys

DIRECTIONS = {
    'L': (-1, 0),  # left
    'R': (+1, 0),  # right
    'D': (0, -1),  # down
    'U': (0, +1),  # up
}


def execute_move(H, T, direction, num_moves, visited):
    for _ in range(num_moves):
        # overlapping: only move head
        if H == T:
            H = (H[0] + DIRECTIONS[direction][0],
                 H[1] + DIRECTIONS[direction][1])
        # next to each other in a '+' fashion: move T only if H moves in same direction
        elif abs(H[0] - T[0]) + abs(H[1] - T[1]) == 1:
            H = (H[0] + DIRECTIONS[direction][0],
                 H[1] + DIRECTIONS[direction][1])
            if abs(H[0] - T[0]) == 2 or abs(H[1] - T[1]) == 2:
                T = (T[0] + DIRECTIONS[direction][0],
                     T[1] + DIRECTIONS[direction][1])
                visited.add(T)
        # next to each other in an 'x' fashion: move T only if H moves farther away
        else:
            H_prev = H
            H = (H[0] + DIRECTIONS[direction][0],
                 H[1] + DIRECTIONS[direction][1])
            if (abs(H[0] - T[0]) + abs(H[1] - T[1])) == 3:
                T = H_prev
                visited.add(T)

    return H, T, visited


def main():
    with open(sys.argv[1]) as input:
        lines = input.read().splitlines()

    # Initial position of Head and Tail.
    H = T = (0, 0)

    # Tuple with (x, y) coordinates, assume (0, 0) is the starting point.
    visited = {(0, 0)}

    for line in lines:
        direction, num_moves = line.split(' ')
        H, T, visited = execute_move(H, T, direction, int(num_moves), visited)

    # Part 1
    print(len(visited))


if __name__ == '__main__':
    main()

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2022: Day 8

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 11 Dec 2022 00:00:00 +0000

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #8 puzzle.

Count visible trees and find best scenic score.

#!/usr/bin/env python3
import itertools
import sys

DIRECTIONS = [
    [-1, 0],  # left
    [+1, 0],  # right
    [0, -1],  # down
    [0, +1],  # up
]


def is_visible(lines, x, y, is_scenic):
    this_tree = lines[y][x]
    scenic = 1

    for direction in DIRECTIONS:
        visible = True

        step = 1
        while True:
            next_x = x + step * direction[0]
            next_y = y + step * direction[1]

            if 0 <= next_x < len(lines[0]) and 0 <= next_y < len(lines):
                next_tree = lines[next_y][next_x]
                if next_tree >= this_tree:
                    visible = False
                    break
                step += 1
            else:
                step -= 1
                break

        scenic *= step

        if visible and not is_scenic:
            return visible

    return scenic if is_scenic else visible


def compute_inner_visible_trees(lines, *, is_scenic):
    """
    Cartesian product: [y][x]
    0 ---> x
    |
    |
  y v
    """
    if is_scenic:
        return max(int(is_visible(lines, x, y, is_scenic)) for (x, y) in itertools.product(range(1, len(lines[0]) - 1), range(1, len(lines) - 1)))
    else:
        return sum(int(is_visible(lines, x, y, is_scenic)) for (x, y) in itertools.product(range(1, len(lines[0]) - 1), range(1, len(lines) - 1)))


def main():
    with open(sys.argv[1]) as input:
        lines = input.read().splitlines()

    outer_visible_trees = 2 * (len(lines) + len(lines[0])) - 4

    # Part 1
    print(outer_visible_trees + compute_inner_visible_trees(lines, is_scenic=False))

    # Part 2
    print(compute_inner_visible_trees(lines, is_scenic=True))


if __name__ == '__main__':
    main()

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2022: Day 7

serendipity@perrotta.dev (Thiago Perrotta) — Thu, 08 Dec 2022 00:00:00 +0000

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #7 puzzle.

Find small directories and directory to delete for update.

#!/usr/bin/env python3
from collections import defaultdict
import sys


def exec_cd(directory, pwd):
    if directory == '..':
        pwd = '/'.join(pwd.split('/')[:-2]) + '/'
    elif directory == '/':
        pwd = '/'
    else:
        pwd += directory + '/'
    return pwd


def parse_line(line, FILE_TO_SIZE, pwd):
    if line.startswith('$ cd '):
        dir = line.split('$ cd ')[1]
        pwd = exec_cd(dir, pwd)
    elif line.startswith('$ ls'):
        pass
    elif line.startswith('dir '):
        dir = pwd + line.split('dir ')[1]
    else:
        size, file_basename = line.split(' ')
        file = pwd + file_basename
        FILE_TO_SIZE[file] = int(size)
    return pwd


def parse_input(lines, *, FILE_TO_SIZE, pwd):
    for line in lines:
        pwd = parse_line(line, FILE_TO_SIZE, pwd)
    return FILE_TO_SIZE


def main():
    with open(sys.argv[1]) as input:
        lines = input.read().splitlines()

    FILE_TO_SIZE = parse_input(lines, FILE_TO_SIZE={}, pwd='/')
    DIRECTORY_TO_SIZE = defaultdict(int)

    for file, size in FILE_TO_SIZE.items():
        components = file.split('/')[:-1]
        for i in range(1, len(components) + 1):
            directory = '/'.join(components[:i])
            DIRECTORY_TO_SIZE[directory] += FILE_TO_SIZE[file]

    # Minor fixes for '/' canonicalization
    DIRECTORY_TO_SIZE['/'] = DIRECTORY_TO_SIZE['']
    del DIRECTORY_TO_SIZE['']

    # Part 1
    print(sum([value for value in DIRECTORY_TO_SIZE.values() if value <= 100000]))

    # Part 2
    TOTAL_DISK = 70000000
    USED_DISK = DIRECTORY_TO_SIZE['/']
    AVAILABLE_DISK = TOTAL_DISK - USED_DISK

    print(next(value for value in sorted(DIRECTORY_TO_SIZE.values())
          if (AVAILABLE_DISK + value) >= 30000000))


if __name__ == '__main__':
    main()

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2022: Day 6

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 07 Dec 2022 00:00:00 +0000

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #6 puzzle.

Find start-of-packet and start-of-message markers in data stream.

#!/usr/bin/env python3
from collections import defaultdict
import sys


def all_different(window):
    hash = defaultdict(int)
    for el in window:
        hash[el] += 1
    return not any(map(lambda x: x > 1, hash.values()))


def find_marker(buffer, size):
    for i in range(len(buffer) - (size - 1)):
        window = buffer[i:i + size]
        if (all_different(window)):
            return i + size


def main():
    with open(sys.argv[1]) as input:
        lines = input.read().splitlines()

    buffer = lines[0]

    # Part 1
    print(find_marker(buffer, 4))

    # Part 2
    print(find_marker(buffer, 14))


if __name__ == '__main__':
    main()

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2022: Day 5

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 06 Dec 2022 00:00:00 +0000

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #5 puzzle.

Rearrange crate stacks. Part two moves crates in order rather than one by one.

#!/usr/bin/env python3
import itertools
import sys
from copy import deepcopy


def parse_input(crates_unparsed):
    """
    Returns a dictionary in the following form:

    {
      1: 'ZN',
      2: 'MCD',
      3: 'P',
    }
    """

    crates = {}

    num_stacks = (len(crates_unparsed[0]) + 1) // 4
    max_height = len(crates_unparsed) - 1

    for i_stack in range(1, num_stacks + 1):
        stack_xaxis = 4 * (i_stack - 1) + 1

        # List comprehension version, not super readable:
        # crates[i_stack] = ''.join(list(filter(lambda x: x != ' ', [crates_unparsed[max_height - i][stack_xaxis]
        #                                                            for i in range(1, max_height + 1)])))

        crates[i_stack] = ''
        for i in range(1, max_height + 1):
            crate = crates_unparsed[max_height - i][stack_xaxis]
            if crate != ' ':
                crates[i_stack] += crate

    return crates


def move_crates(moves_unparsed, crates, *, reverse):
    for move_unparsed in moves_unparsed:
        _, quantity, _, src, _, dst = move_unparsed.split(' ')
        quantity, src, dst = int(quantity), int(src), int(dst)
        move_crate(crates, quantity, src, dst, reverse)
    return crates


def move_crate(crates, quantity, src, dst, reverse):
    if reverse:
        crates[dst] += crates[src][(-1) * quantity:][::-1]
    else:
        crates[dst] += crates[src][(-1) * quantity:]
    crates[src] = crates[src][:(-1) * quantity]


def main():
    with open(sys.argv[1]) as input:
        lines = input.read().splitlines()

    crates_unparsed, moves_unparsed = [list(group) for key, group in itertools.groupby(
        lines, lambda a: a == "") if not key]

    crates = parse_input(crates_unparsed)

    # Part 1
    crates_part1 = move_crates(moves_unparsed, deepcopy(crates), reverse=True)
    print(''.join([value[-1] for value in crates_part1.values()]))

    # Part 2
    crates_part2 = move_crates(moves_unparsed, deepcopy(crates), reverse=False)
    print(''.join([value[-1] for value in crates_part2.values()]))


if __name__ == '__main__':
    main()

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2022: Day 4

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 05 Dec 2022 00:00:00 +0000

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #4 puzzle.

Find overlapping cleaning assignment pairs.

#!/usr/bin/env python3
import sys


def eitherContains(e1, e2):
    if e1[0] >= e2[0] and e1[1] <= e2[1]:
        return 1
    elif e2[0] >= e1[0] and e2[1] <= e1[1]:
        return 1
    else:
        return 0


def anyOverlap(e1, e2):
    return int((e1[1] >= e2[0]) and (e1[0] <= e2[1]))


def main():
    with open(sys.argv[1]) as input:
        lines = input.read().splitlines()

    totalEitherContains = 0
    totalAnyOverlap = 0

    for line in lines:
        # [['2', '4'], ['6', '8']]
        [e1, e2] = [el.split('-') for el in line.split(',')]
        # [2, 4], [6, 8]
        e1, e2 = list(map(int, e1)), list(map(int, e2))

        totalEitherContains += eitherContains(e1, e2)
        totalAnyOverlap += anyOverlap(e1, e2)

    # Part 1
    print(totalEitherContains)

    # Part 2
    print(totalAnyOverlap)


if __name__ == '__main__':
    main()

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2022: Day 2

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 03 Dec 2022 00:00:00 +0000

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #2 puzzle.

Rock paper scissors strategy. Part two uses win/draw/lose outcomes.

#!/usr/bin/env python3
import sys

MOVE_SCORE = {
    # theirs
    'A': 1,  # rock
    'B': 2,  # paper
    'C': 3,  # scissors

    # mine
    'X': 1,  # rock
    'Y': 2,  # paper
    'Z': 3,  # scissors
}


def battle(theirs, mine):
    if (theirs, mine) in [('A', 'X'), ('B', 'Y'), ('C', 'Z')]:
        return 3  # draw
    elif (theirs, mine) in [('A', 'Z'), ('B', 'X'), ('C', 'Y')]:
        return 0  # defeat
    else:
        return 6  # victory


def strategy(theirs, mine):
    if mine == 'Y':  # draw
        return chr(ord(theirs) + (ord('X') - ord('A')))
    elif mine == 'X':  # lose
        return {'A': 'Z', 'B': 'X', 'C': 'Y'}[theirs]
    else:  # win
        assert mine == 'Z'
        return {'A': 'Y', 'B': 'Z', 'C': 'X'}[theirs]


def main():
    with open(sys.argv[1]) as input:
        lines = input.read().splitlines()

    score1, score2 = 0, 0

    for line in lines:
        theirs, mine = line.split(' ')

        score1 += MOVE_SCORE[mine] + battle(theirs, mine)

        mine = strategy(theirs, mine)
        score2 += MOVE_SCORE[mine] + battle(theirs, mine)

    print(score1)
    print(score2)


if __name__ == '__main__':
    main()

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2022: Day 3

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 03 Dec 2022 00:00:00 +0000

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #3 puzzle.

Find misplaced items in rucksacks. Part two finds common items across three rucksacks.

#!/usr/bin/env python3
import sys


def priority(item):
    if item.islower():
        return ord(item) - ord('a') + 1
    else:
        assert item.isupper()
        return ord(item) - ord('A') + 27


def main():
    with open(sys.argv[1]) as input:
        lines = input.read().splitlines()

    total_priority = 0

    # Part 1
    for line in lines:
        c1 = line[:len(line)//2]
        c2 = line[len(line)//2:]
        item = next(iter(set(c1).intersection(c2)))
        total_priority += priority(item)

    print(total_priority)

    # Part 2
    print(sum([priority(next(iter(set(line1).intersection(line2).intersection(line3))))
               for (line1, line2, line3) in zip(lines[::3], lines[1::3], lines[2::3])]))


if __name__ == '__main__':
    main()

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2022: Day 1

serendipity@perrotta.dev (Thiago Perrotta) — Thu, 01 Dec 2022 00:00:00 +0000

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #1 puzzle.

Find the elf carrying the most calories. Part two finds the top three elves.

#!/usr/bin/env python3
import itertools
import sys


def main():
    with open(sys.argv[1]) as input:
        lines = input.read().splitlines()

    # ['1', '2', '', '3'] -> [1, 2, '', 3]
    lines = [int(line) if line != "" else line for line in lines]

    # [1, 2, '', 3] -> [[1, 2], [3]]
    groups = [list(group) for key, group in itertools.groupby(
        lines, lambda a: a == "") if not key]

    # Part 1
    calories = [sum(group) for group in groups]

    print(max(calories))

    # Part 2
    print(sum(sorted(calories, reverse=True)[:3]))


if __name__ == '__main__':
    main()

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2021: Day 1

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 26 Nov 2022 00:00:00 +0000

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #1 puzzle.

Count the number of times a measurement increases from one to the next. Part two uses a sliding window of three measurements.

#!/usr/bin/env python3
import sys

with open(sys.argv[1]) as input:
    lines = input.readlines()

numbers = [int(line.strip()) for line in lines]

# Part 1
print(sum(y > x for x, y in zip(numbers[:-1], numbers[1:])))

# Part 2
print(sum(y > x for x, y in zip(numbers[:-3], numbers[3:])))

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2021: Day 2

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 26 Nov 2022 00:00:00 +0000

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #2 puzzle.

Calculate final position using forward, down, and up instructions. Part two introduces an aim variable.

#!/usr/bin/env python3
import sys

with open(sys.argv[1]) as input:
    lines = input.readlines()

units = [line.split(' ') for line in lines]

# Part 1
x = sum(int(unit[1]) for unit in units if unit[0] == 'forward')
y = sum(int(unit[1]) if unit[0] == 'down' else (-1) * int(unit[1]) if unit[0] == 'up' else 0 for unit in units)

print(x * y)

# Part 2
x = 0
y = 0
aim = 0

for unit in units:
    instruction = unit[0]
    distance = int(unit[1])

    if instruction == 'forward':
        x += distance
        y += aim * distance
    elif instruction == 'up':
        aim -= distance
    elif instruction == 'down':
        aim += distance

print(x * y)

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2021: Day 3

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 26 Nov 2022 00:00:00 +0000

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #3 puzzle.

Calculate power consumption using binary diagnostic data. Part two finds oxygen and CO2 ratings using bit criteria.

#!/usr/bin/env python3
import numpy as np
import sys

with open(sys.argv[1]) as input:
    lines = input.readlines()

lines = [list(line.strip()) for line in lines]

# Part 1
transposed = np.array(lines).T.tolist()

gamma_str = ''.join(['1' if col.count('1') > col.count('0') else '0' for col in transposed])
gamma = int(gamma_str, base = 2)

epsilon_str = ''.join(['0' if c == '1' else '1' for c in gamma_str])
epsilon = int(epsilon_str, base = 2)

print(gamma * epsilon)

# Part 2
def oxygen(lines, depth = 0):
    if len(lines) == 1:
        return int(''.join(lines[0]), base = 2)

    transposed = np.array(lines).T.tolist()

    most_common = '1' if transposed[depth].count('1') >= transposed[depth].count('0') else '0'

    return oxygen([line for line in lines if line[depth] == most_common], depth + 1)

def co2(lines, depth = 0):
    if len(lines) == 1:
        return int(''.join(lines[0]), base = 2)

    transposed = np.array(lines).T.tolist()

    most_common = '1' if transposed[depth].count('1') < transposed[depth].count('0') else '0'

    return co2([line for line in lines if line[depth] == most_common], depth + 1)

print(oxygen(lines) * co2(lines))

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2021: Day 4

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 26 Nov 2022 00:00:00 +0000

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #4 puzzle.

Play bingo with submarine boards. Part one finds first winning board, part two finds last winning board.

#!/usr/bin/env python3
import re
import sys

with open(sys.argv[1]) as input:
    lines = input.readlines()

draws = list(map(int, lines[0].strip().split(',')))

num_boards = len(lines) // 6

boards = [[[[int(el), False] for el in re.split(r'[ ]+', r.strip())] for r in board] for board in [lines[(6 * n + 2) : 6 * n + 7] for n in range(num_boards)]]

def mark_board(board, draw):
    for row in board:
        for el in row:
            if el[0] == draw:
                el[1] = True
                return

def check_rows(board):
    for row in board:
        if all(marked for _, marked in row):
            return True
    return False

def check_cols(board):
    for col in zip(*board):
        if all(marked for _, marked in col):
            return True
    return False

def check_board(board):
    return check_rows(board) or check_cols(board)

def score(board, draw):
    return sum([n for n, marked in sum(board, []) if not marked]) * draw

def part1(boards, draws):
    for draw in draws:
        for board in boards:
            mark_board(board, draw)
            if check_board(board):
                print(score(board, draw))
                return

def part2(boards, draws):
    finished = [False] * len(boards)

    for draw in draws:
        for i, board in enumerate(boards):
            if finished[i]:
                continue
            mark_board(board, draw)
            if check_board(board):
                finished[i] = True
                if all(finished):
                    print(score(board, draw))
                    return

part1(boards, draws)
part2(boards, draws)

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2021: Day 5

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 26 Nov 2022 00:00:00 +0000

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #5 puzzle.

Draw lines on a grid and count overlapping points. Part two includes diagonal lines.

#!/usr/bin/env python3
from collections import defaultdict
from itertools import count, islice
import sys

with open(sys.argv[1]) as input:
    lines = input.read().splitlines()

def direction(a, b):
    """
    3, 5 => +1
    5, 3 => -1
    5, 5 => 0
    """
    return 1 if b > a else -1 if a > b else 0

def fill(floor, x1, y1, x2, y2):
    for x, y in islice(zip(count(start = x1, step = direction(x1, x2)), count(start = y1, step = direction(y1, y2))), max(abs(x2 - x1), abs(y2 - y1)) + 1):
        floor[(x, y)] += 1

def part1():
    floor = defaultdict(int)

    for line in lines:
        (x1, y1), (x2, y2) = _, _ = [list(map(int, pair.split(','))) for pair in line.split(' -> ')]
        if x1 == x2 or y1 == y2:
            fill(floor, x1, y1, x2, y2)

    print(sum(el >= 2 for el in floor.values()))

def part2():
    floor = defaultdict(int)

    for line in lines:
        (x1, y1), (x2, y2) = _, _ = [list(map(int, pair.split(','))) for pair in line.split(' -> ')]
        fill(floor, x1, y1, x2, y2)

    print(sum(el >= 2 for el in floor.values()))

part1()
part2()

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2021: Day 6

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 26 Nov 2022 00:00:00 +0000

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #6 puzzle.

Simulate lanternfish population growth using a counter to track fish by their internal timer.

#!/usr/bin/env python3
from collections import Counter
import sys

with open(sys.argv[1]) as input:
    numbers = list(map(int, input.read().split(',')))

def simulation(days):
    fish = Counter(numbers)

    for _ in range(days):
        next_fish = Counter()
        for timer, count in fish.items():
            if timer == 0:
                next_fish[8] += fish[timer]
                next_fish[6] += fish[timer]
            else:
                next_fish[timer - 1] += fish[timer]
        fish = next_fish

    print(sum(fish.values()))

simulation(80)
simulation(256)

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2021: Day 7

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 26 Nov 2022 00:00:00 +0000

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #7 puzzle.

Calculate optimal position for crab submarines. Part one uses median, part two uses triangular cost function.

#!/usr/bin/env python3
import statistics
import sys

with open(sys.argv[1]) as input:
    numbers = list(map(int, input.read().split(',')))

def part1():
    median = int(statistics.median(numbers))
    fuel = int(sum(abs(median - number) for number in numbers))

    print(fuel)

def cost(n):
    return (n * (n + 1)) / 2

def part2():
    fuel = float('inf')

    for guess in range(min(numbers), max(numbers) + 1):
        fuel = min(int(sum(cost(abs(guess - number)) for number in numbers)), fuel)

    print(fuel)

part1()
part2()

— § —

Reply via email

#advent-of-code #dev %coding

Advent of Code 2021: Day 8

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 26 Nov 2022 00:00:00 +0000

♠ Refer to the previous post about AoC, and to the git repository with my solutions in Python 3.

Link to Day #8 puzzle.

Decode seven-segment display signals. Count unique digit segments in output values.

#!/usr/bin/env python3
import sys

with open(sys.argv[1]) as input:
    lines = input.read().splitlines()

def part1():
    total = 0

    for line in lines:
        outputs = line.split(' | ')[1].split(' ')
        total += sum(len(output) in [2, 3, 4, 7] for output in outputs)

    print(total)

part1()

— § —

Reply via email

#advent-of-code #dev %coding

★ Advent of Code

serendipity@perrotta.dev (Thiago Perrotta) — Fri, 28 Jan 2022 17:44:00 -0500

♠ Last year I found out about Advent of Code.

You said what? #

Advent of Code by Eric Wastl happens every year since 2015, every December from the 1st to the 25th. Each day there’s a new programming challenge¹ split into two parts. The first part tends to be easier than the second one. The second part usually builds upon the first one, being a follow-up task that requires more steps and/or with a higher degree of complexity. You can’t always reuse the bits from the first part to solve the second one though.

For those familiar with programming contests like ACM ICPC or OBI, or online judges like SPOJ or UVa, advent of code feels like home. The main difference is that there is no time pressure and no need to write spaghetti and unreadable code; in fact, writing readable and elegant solutions is encouraged (citation needed…).

For those familiar with FAANG/Tech whiteboard interviews, advent of code feels a lot like a typical interview. I would even go further and say it’s a great way to practice for interviews.

It is a great moment to either (i) learn a new exciting programming language or (ii) improve your mastery on programming languages that you already know. I know several people (see below) that used AoC² to learn Rust or Kotlin or whatever else was exciting for them at the time. It’s surprising that the official Kotlin Docs even contain a section called Advent of Code puzzles in idiomatic Kotlin.

Some folks go even further and use it to practice their code golfing³ or even Google Sheets skills. I have a deep amount of respect for them as it’s quite a challenge. If you think it stops there, I’ve also seen solutions in awk and sed.

Another positive aspect of AoC is that it has an integrated dashboard that tracks your progress as you go. It’s a simple element of gamification that immensely improves motivation and fun. You really feel a big desire to collect all those 50 stars…

What about me? #

My goal for 2021 was relatively less ambitious than that, I just wanted to improve my Python skills, more specifically Python 3. I learned Python 2 during my first year in university and used it sparingly at work and for personal endeavours, but always had a knowledge gap in Python 3.

I set up a public git repository with my solutions and aspired to write simple and elegant python, my only constraint was to limit myself to what is available in the standard library of a vanilla python3 installation in Alpine linux, with the exception of numpy which is widespread enough to deserve an entry in my requirements.txt, and of course devtools like debuggers, linters and auto formatters as needed.

As an additional, non-programming challenge I also limited myself to only use the command line. This basically meant no IDEs⁴. My programming environment was ultimately ssh to an Alpine Linux VPS + tmux + vim. To make my life easier, one of the first tasks I accomplished was to write a generic Makefile to help me test and run my scripts. A typical invocation would look like:

$ make DEBUG=1 DAY=3

…whereas I could choose between the sample input versus the real one with DEBUG, and the puzzle day with DAY.

Was the experience worth it? Definitely yes! Even though I only completed ~8 puzzles out of the 25 ones due to having my attention split with another project I was working on at the time, the thematic submarine puzzles were hella fun and I learned a lot of python 3 on the way.

A few highlights of what I learned and used from my python 2to3 transition were f-strings / string interpolation (print(f'The sum is {sum}')), “everything is an iterator now” even map and range, the standard library is awesome and sometimes you stumble upon useful abstractions like Counter and defaultdict, sort is different now (key instead of comparison function), this pdb debugger thingy, among other topics I can’t remember at the moment. I realized the only concept that was previously familiar was the different syntax of the print function (you have to use parentheses now).

In terms of workflow, I also learned that virtual environments are now supported natively⁵ (python -m venv), direnv is an amazing tool to automate/manage environments in git repositories and also happens to have first-class python integration, pylint and autopep8 are good integrations with vim to help spot basic errors and/or suggest best practices, and numpy takes forever to build from source.

What about the community? #

AoC enjoys a lot of popularity and zeitgeist, especially during times of the COVID-19 pandemic, but even before then. There’s a large /r/adventofcode subreddit community, lots of people share their solution snippets and impressions on Twitter (#AdventOfCode), there’s a ton of public git repositories on GitHub where people share their coding solutions, in pretty much any programming language you can think of, and finally there are many screencasts on YouTube. The Internet in the 2020s sparks creativity in every unimaginable corner.

There’s so much information that it’s impossible to stay on top of everything. Here is a small list of repositories that I followed this year, most of those are acquaintances/friends and/or stumbled upon Twitter:

C++:

https://github.com/riuri/adventofcode

Python:

Rust:

Edit (2024-08-06): Additions from 2022:

C++:

https://github.com/eariassoto/advent-of-code-cpp

Python:

I find it’s really constructive and useful (and also fun) to peek at other people’s solutions after I coded my own. I have extensive (albeit kinda rusty these days) experience with C++ so I wanted to follow at least one repository coded with it; since I wrote my solutions in python it was also a natural choice to follow a few python repositories; and, finally, I wanted to peek at some languages I am not familiar with to get a gist of them. This year I watched Rust and a few bits of Clojure and Kotlin on Twitter.

Finally, for some extra inspiration, there are also some 10x programmers⁶ out there that seem to be fans of AoC as well: Peter Norvig and Russ Cox (rsc). There are probably several others I am not aware of.

Final remarks #

I am hoping to participate in AoC this year (2022) as well, and possibly revisit the 2021 puzzles and resolve the rest of the ones I missed as time permits.

Hopefully this post encourages and motivates you to try Advent of Code as well! Happy coding.

Or puzzle, if you will. ↩︎
Acronym not to be confused with a certain ~~annoying~~^W politician. ↩︎
For those unfamiliar with the concept, code golfing is all about writing a correct solution with the fewest amount of characters. ↩︎
For example: PyCharm, and also VSCode, which is getting so big these days I don’t even know if it’s possible to just call it a simple text editor anymore. ↩︎
Back in the days, virtualenvwrapper was all the rage. ↩︎
The 10x programmer thing is a well-known joke however in this instance the mentioned characters are indeed superb programmers that I immensely respect. ↩︎

— § —

Reply via email

#advent-of-code #bestof #dev %coding

★ Direnv: Automate your Environment Variables

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 04 Jan 2022 00:34:07 -0500

♠ Direnv is a tool to automate your shell to automatically load and unload environment variables on-the-fly, on a per-project (per-directory) basis.

Preliminaries: Is it worth it? #

Questions I like to ask myself before deciding whether to invest my time into learning and potentially adopting a foreign tool are the following:

Is it popular and stable enough? Is it abandonware?

Popularity #

Popularity is relative, it doesn’t need to be worthy of the Hacker News frontpage nor Hotness on Reddit, but it needs to be widely available in popular Linux distributions and/or package managers, one install command away from my development environment.

Repology is a good proxy for popularity. Looking at direnv therein, it’s available for Alpine, Arch, Debian, Fedora, FreeBSD, HomeBrew, Nix, OpenBSD, Ubuntu…that’s more than enough, we can safely conclude direnv is widely popular.

The main takeaway we want to confirm is whether the project isn’t too niche and/or an one-man show. Seeing signs of a small-ish community and/or occasional contributions from external users/developers helps build confidence and give credibility to the project.

Stability and Abandonware #

Stability is easier to define than popularity and can often be determined just by taking a quick glance at the github (or whichever other forge it’s hosted in) page of the project.

At the time of this writing, the latest release of direnv was about a week ago (2.30.2, Dec 28th 2021). It’s definitely not abandonware and it’s well maintained. A few signs that help corroborate that:

Several PRs were merged recently
Its issue tracker is quite active, with a good mix of feature requests and bugs
I don’t like to judge the project based on the number of issues it has, especially if it’s popular. Chromium has 60k+ issues at the time of this writing, yet I wouldn’t call it bleeding edge. Common sense applies. Since direnv has been around for a while and it’s relatively popular, 150+ open issue seems acceptable to me.

Now that direnv passed the Litmus test for adoption¹, let’s get our hands dirty.

Installation #

There’s nothing special here, as direnv is widely packaged. Pick your poison:

$ sudo pacman -Syu direnv  # Arch Linux
$ doas apk add direnv  # Alpine Linux
$ sudo apt install direnv  # Debian-based distros

Is it lightweight?

$ apk info -L direnv
direnv-2.30.1-r0 contains:
usr/bin/direnv

Hell yes! More lightweight than that? Impossible. It’s a single binary thanks to Golang. No tons of files or dependencies. I mean:

$ du -sh /usr/bin/direnv
7.5M    /usr/bin/direnv

…it’s a 7MB binary, let’s not get ahead of ourselves. But that’s fine, really, it’s just a dev tool, we don’t really deploy it to prod.

Use Cases #

Everything is controlled with a .envrc file within a repository root. A typical file could look like this:

export HOUSE="ATREIDES"
layout python3

The upstream website does a great job at summarizing use cases. I am not here to duplicate documentation, so please go ahead and read it. That said, here are some example use cases I found useful:

Use Case: Python #

Python developers often need to create different virtual environments for different projects. For example, I was participating in Advent of Code last year and wrote my solutions in Python 3: https://github.com/thiagowfx/adventofcode.

Each day² I would cd ~/projects/adventofcode, and then do source ~/.venv/bin/activate. And guess what, that’s for the first terminal where I’d run make, I’d also spawn a second one with vim, thereby needing to activate the virtual environment twice.

And this is assuming the virtual environment already exists. If it didn’t — for example, after a vanilla git clone, I’d have to do python -m venv .venv first.

Quickly all of this became repetitive and annoying. I kinda “cheated” and stopped using the virtualenv for a few days, relying on my Linux distribution package manager instead:

% apk add py3-{autopep8,pyflakes,numpy,pylint}

This way, my

import numpy

would correctly work and not yell that numpy was nowhere to be found.

It’s not very clean, but it worked. However eventually I wanted to become cleaner and leaner and automate my virtual environment setup. I uninstalled the aforementioned packages after a few days:

% apk del py3-{autopep8,pyflakes,numpy,pylint}

…therefore forcing me to come up with a better setup. I always had direnv in my TODO list, and this was the perfect moment to try it out.

How does direnv address this?

Add the direnv hook to your shell. I actively use two shells³, bash and zsh, so I did it twice and then added it to my dotfiles:

Bash:

#!/bin/bash
# https://direnv.net/
if hash direnv >/dev/null 2>&1; then
        eval "$(direnv hook bash)"
fi

Zsh:

#!/bin/zsh
# https://direnv.net/
if (( $+commands[direnv] )); then
        eval "$(direnv hook zsh)"
fi

Set up direnv in the AOC repository:

$ cat ~/projects/adventofcode/.envrc
layout python3
$ direnv allow  # Only needs to be done once

That’s it: It’s a single line of configuration. Now what does it do? All of the above. No magic: whenever you cd into the project directory or any of its subdirectories with one of the configured shells, if the venv doesn’t exist:

it will be automatically created;
then it will be sourced

Now you may ask yourself: Why go through all this trouble? Why not simply create a shell script to do exactly that for you automatically? That’s perfectly fine, it’s a matter of taste. But then you’ll have to maintain that script. The python ecosystem keeps changing — a few years ago I was using virtualenvwrapper to manage virtual environments, these days it doesn’t exist anymore, people use either python -m env or pyenv or poetry or…it never ends. Drew DeVault wrote a good piece about that.

XKCD Courtesy of Randall Munroe

Maintenance is not the only burden, scalability is also one: If you use python in several repositories, you’ll now have to include your script in all of them.

Considering that direnv is flexible enough in other scenarios, I consider its adoption in this situation a good trade-off to make.

Use Case: Hugo #

This blog is written in Hugo. I have a Makefile with a bunch of environment variables to manage its setup:

$ make dev

Whenever I am working in my VPS, for reasons outside of the scope of this post I need to use a different port other than the default one for Hugo (1313). Since I am using variables, I could just do:

$ make PORT=1234 dev

However, to make this change permanent (“fire-and-forget”), I could also do:

$ echo 'export PORT=1234' | tee -a .envrc
$ direnv allow  # Only needs to be done once
$ make dev

This way, whenever I run make I wouldn’t even need to think twice about which port to use.

Of course, a small improvement that should be done in this scenario is to add direnv related files to your .gitignore:

$ git ignore direnv >> .gitignore

# Created by https://www.toptal.com/developers/gitignore/api/direnv
# Edit at https://www.toptal.com/developers/gitignore?templates=direnv

### direnv ###
.direnv
.envrc

# End of https://www.toptal.com/developers/gitignore/api/direnv

Other use cases? #

I don’t have other real use cases to share because only recently I became familiarized with direnv. That said, the direnv docs are very comprehensive of its full potential usage.

Some use cases that I like:

dotenv: Automatically sources .env (note: not to confuse with .envrc) files, which are widely common in projects managed with docker-compose.
source_env + env_vars_required: Alongside .gitignore, this is a great way to source secrets (e.g. API keys or tokens) and not accidentally check them into your repository.
fetchurl: bash | curl is a cancer⁴ that should arguably be stopped due to its inherent security risks. That said, direnv provides a safer way to work with it because you can specify a hash to ensure you’re downloading the same script — if an attacker or malicious actor modified it, direnv would throw an error.
path_add: If your project outputs to e.g. build/<...>/bin or similar (typical in cmake projects and AFAIK in Rust ones too), you could add that directory to your PATH so that you could easily execute your binaries, without having to write the full subdirectory path each time.
layout: Besides python, direnv supports several other programming languages out-of-the-box. Popular examples include go, nix, node, perl and ruby.

Downsides? #

One could call direnv bloated because of all of the aforementioned capabilities. If it doesn’t spark joy for your taste, consider using autoenv which is basically a leaner version of direnv, meant mostly for doing one thing and doing it well: setting and unsetting variables.

Other than that, direnv is pretty much a great piece of software.

One thing I didn’t cover is how secure it is: You need to run direnv allow explicitly in order to tell direnv that you trust a given .envrc file. If you don’t do it, direnv will refuse to source it:

$ touch .envrc
direnv: error ~/projects/foo/.envrc is blocked. Run `direnv allow` to approve its content

If you run direnv allow but later on the file is modified (for example, after git pull, whereby you retrieve a modification from a teammate), direnv will once again refuse to operate. You’ll need to whitelist it again by re-running direnv allow. Direnv will snapshot/hash the file contents of .envrc remember it across sessions.

References #

Tools You Should Know About: direnv

Obviously the aforementioned list was non-exhaustive. There are a few other questions that you may want to ask, out of scope of this article, such as: (i) does the project have an OSS or FLOSS license? (ii) does the project depend on Java? ↩︎
Advent of code challenges are released one by one, thereby forcing you to wait until the next day in order to get the next challenge. ↩︎
more on this another day ↩︎
c.f. https://curlpipesh.tumblr.com/, https://gnu.moe/wallofshame.md ↩︎

— § —

Reply via email

#advent-of-code #bestof #dev