First tent-grow. Zkittlez OG Auto from Barney's Farm. Today marks day 70 since putting the seed into the peat pad. I expect maybe a week more. Two, tops.

I'm not looking for a solution or even code, just a hint. Here's what I currently do:

1. Add the current position and heading to the recorded path
2. Check if turning right would lead back onto the recorded path in the same direction we walked it before
3. Check if the next field is obstructed
   1. If so, turn right
   2. Repeat until no longer blocked
4. Update current position

This approach works fine for the unit test, but yields a result too low for the puzzle input. I tried adding recursion to the party check, but even 20 levels of recursion didn't sufficiently increase the amount of options found, suggesting I'm missing a mechanism to identify them.

Any clues?

Current state of affairs:

from math import sumprod
from operator import add
from pathlib import Path


def parse_input(input: str) -> list[list[int]]:
    return input.strip().splitlines()


def find_guard(world: list[list[int]]) -> tuple[int]:
    for y, line in enumerate(world):
        x = line.find("^")
        if x > -1:
            return (y, x)
    return (-1, -1)  # No guard


def turn(heading: tuple[int]) -> tuple[int]:
    mat = [(0, 1), (-1, 0)]
    return tuple([sumprod(col, heading) for col in mat])


def step(pos: tuple[int], heading: tuple[int]) -> tuple[int]:
    return tuple(map(add, pos, heading))


def is_blocked(world: list[list[str]], guard: tuple[int], heading: tuple[int]) -> bool:
    pos = step(guard, heading)
    try:
        return world[pos[0]][pos[1]] == "#"
    except IndexError:
        return False


def cast_ray(
    world: list[list[int]], start: tuple[int], heading: tuple[int]
) -> list[tuple[int]]:
    pos = step(start, heading)
    ray = []
    try:
        while world[pos[0]][pos[1]] != "#":
            ray.append(pos)
            pos = step(pos, heading)
    except IndexError:
        # Left the world
        ...
    return ray


def part_one(input: str) -> int:
    world = parse_input(input)
    guard = find_guard(world)
    heading = (-1, 0)
    while (
        guard[0] >= 0
        and guard[0] < len(world)
        and guard[1] >= 0
        and guard[1] < len(world[guard[0]])
    ):
        while is_blocked(world, guard, heading):
            heading = turn(heading)
        world[guard[0]] = f"{world[guard[0]][:guard[1]]}X{world[guard[0]][guard[1]+1:]}"
        guard = tuple(map(add, guard, heading))
    return sum([line.count("X") for line in world])


def part_two(input: str) -> int:
    world = parse_input(input)
    guard = find_guard(world)
    heading = (-1, 0)
    path = {}
    options = 0
    while (
        guard[0] >= 0
        and guard[0] < len(world)
        and guard[1] >= 0
        and guard[1] < len(world[guard[0]])
    ):
        path.setdefault(guard, []).append(heading)
        turned = turn(heading)
        if turned in path.get(guard, []) or turned in [
            d
            for p in set(cast_ray(world, guard, turned)).intersection(set(path.keys()))
            for d in path[p]
        ]:
            # Crossing previous path and turning would cause us to retrace our steps
            # or turning would lead us back into our previous path
            options += 1
        while is_blocked(world, guard, heading):
            heading = turned
        world[guard[0]] = f"{world[guard[0]][:guard[1]]}X{world[guard[0]][guard[1]+1:]}"
        guard = tuple(map(add, guard, heading))
    return options


if __name__ == "__main__":
    input = Path("input").read_text("utf-8")
    print(part_one(input))
    print(part_two(input))

Fermented with black cardamom and garlic (which I'm just noticing I forgot to put on the label 🤷) and puréed with mango and pear.
Added a little rice vinegar and salt to balance the fruit.
It's a little spicier than Sriracha, but not at all unpleasant. Nicely sweet and spicy. You can taste it with a spoon without regretting it.

I'm trying to get networkd to connect to a wireguard endpoint, specifically ProtonVPN, in case it matters. I just can't get it to connect. Has anyone had success with that? Specifically without using wg-quick.

Looking for someone to take over our lease for a 3 1/2 apartment in Petite-Patrie (H2S) starting February 1st 2024.
Lease goes until 31st of October 2024 with option of renewal.
Monthly rent is $1665 including hot water and parking behind the house (electric bill is extra).

The apartment was completely renovated in 2018 with new isolation, windows and doors. It is on the ground floor, very quiet and in walking distance to metro stations (Fabre and Beaubien), supermarkets, cafés and shops.
The bedroom and office both have built-in storage closets. You have full access to the garden in the back and can use it as you wish. Cats are no problem but you will have to check for other pets.
Appliances are NOT included in the lease and we bought them new in 2018 (Stove, fridge with freezer drawer, dishwasher, washing machine and dryer). All are good quality appliances (Whirlpool, Maytag) that work great and we'd prefer them taken over from us (price is negotiable).
All our furniture is also up for sale.

Please send me a message if interested.

Misread the pattern and now I get to redo 16 repeats of 16 rows of cabling plus some moss stitch.
On the plus side I can fix the mistakes I made. And hope I don't make more…

By that I mean randomly generated playlists. Based on either one or multiple tags, songs or artists. Finite or infinite.

Ideally it would allow combining local sources with remote ones for discovering new music. Thinking along the lines of audioscrobbler, Bandcamp and SoundCloud. Maybe one could even hook into Spotify's API, of they allow that.

Does something like this exist? I'm currently running Navidrome and while it's pretty and functional, it's very much a classic Mediaplayer, that just happens to be a website.

Sourdough crust with tomato sauce, topped with onions, pesto seitan sausage, artichoke, zucchini and cheese and half lemon olives.

Hope this fits here.