Advent of Code 2019

[perfringo]

Day #3

I was in real hurry with this one. So I decided to approach this 'systematically' in top-down style. I wanted to do some generator chaining but in order to get ready before my time was up I didn't follow this initial thought. Also - I did vectors decades ago, so I let shapely and numpy to do heavy lifting. This is brute-force and probably there is some math which allows to reach same result with less work.

Puzzel # 1:
'find intersection point with smallest Manhattan distance from start (0,0)'
For that:

• read data from webpage
  
• calculate relative moves
  
• calculate path using relative moves
  
• convert into shapely LineString
  
• find all intersections
  
• find smallest Manhattan distance from intersections
  
• output smallest Manhattan distance
  

Hide/Show

import requests
from shapely.geometry import LineString
import numpy as np

def main():
    moves_1, moves_2 = read_page(day=3)                                                # read moves from page
    wire_1, wire_2 = LineString(wire_path(moves_1)), LineString(wire_path(moves_2))    # calculate paths, convert to LineString
    wires_cross = wire_1.intersection(wire_2)                                          # find intersections
    closest_cross = get_closest(wires_cross)                                           # get smallest Manhattan distance
    print(f'Smallest Manhattan distance is {closest_cross} ')                          # output distance
    fewest_steps = shortest_distance(wire_1, wire_2, wires_cross)                      # find shortest distance to intersection
    print(f'Fewest steps to intersection is {fewest_steps}')                           # output shortest distance
    

def read_page(*,day):
    """
    Read data from webpage, convert to relative moves
    and yield two streams of moves.
    """
    cookie = {'session': '536****'}                                                    # replace with your own cookie
    content = requests.post(f'https://adventofcode.com/2019/day/{day}/input', cookies=cookie)
    series = (serie.split(',') for serie in content.text.split())
    yield from ((rel_move(item) for item in serie) for serie in series)


def rel_move(move):
    """
    Calculate relative moves.
    """
    replacements = str.maketrans('RULD', '  --')
    if move.startswith(('R', 'L')):
        return np.array([0, int(move.translate(replacements))])
    else:
        return np.array([int(move.translate(replacements)), 0])


def wire_path(moves):
    """
    Based on moves calculate wire path.
    Start with central port and add moves to last coordinate.
    """
    central_port = np.array([0, 0])
    path = [central_port]
    for move in moves:
        path.append(path[-1] + move)
    return path


def get_closest(coords):
    """
    Return Manhattan distance closest to central port (0, 0) which is not
    central port itself.
    """
    closest = min(abs(coord.x) + abs(coord.y) for coord in coords if all([coord.x != 0, coord.y !=0]))
    return int(closest)


def shortest_distance(first, second, intersections):
    """
    Calculate shortest distance excluding starting point.
    """
    distances = [first.project(intersection) + second.project(intersection) for intersection in intersections]
    return int(np.partition(distances, 1)[1])

if __name__ == '__main__':
    main()

Puzzle # 2:
Intersection points were already found. So:
'Find smallest distance to intersection point' (function 'shortest_distance' in code above)