Spyke

Posts

Pebble·Pebble SmartwatchbyChais

They might have QA-issues

Received my PT2 last Friday and today (Monday) it fell apart.
Opened a support request. We'll see what comes of it.
And just to clarify, it still works fine. It's just the sticky tape that holds the screen that gave out. Glad I didn't take it into the shower.
On the plus side, I guess the battery is user-replaceable now.

Update: A representative replied to my email, asked for a photo of the serial number and then asked me to file a bug report.
In order to do that I had to create an account, which regrettably can only be done by linking an Apple, Google or GitHub account.
So now I'm waiting for a response on the bug report.

Update 2: Replacement watch is on the way.

Last update:
Replacement has arrived.

View original on sh.itjust.works
29
Comments8
advent_of_code·Advent Of CodebyChais

Stuck on day 6, part 2

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))
View original on sh.itjust.works
12
Comments15
montreal·MontréalbyChais

Looking to transfer our lease in Petite-Patrie

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.










View original on sh.itjust.works
11
Comments4