with open('day_1_1_data.txt', 'r') as f:
    print(sum(int(line) // 3 - 2 for line in f))

with open('day_1_1_data.txt', 'r') as f:
    total = 0
    for num in f:
        while 0 < (num := int(num) // 3 - 2):
            total += num
    print(total)

# part 1
with open("input.txt") as file:
    masses = [int(mass) for mass in file]

print(sum(mass // 3 - 2 for mass in masses))

# part 2
def calc_fuel(mass):
    if mass < 9: return 0
    fuel = mass // 3 - 2 
    return fuel + calc_fuel(fuel)

print(sum(calc_fuel(mass) for mass in masses))

import requests

cookies = {'session': '536xxxxxxxxxx'}
day_1 = requests.post('https://adventofcode.com/2019/day/1/input', cookies=cookies)
result = sum(int(int(fuel) / 3 - 2) for fuel in day_1.text.strip().split('\n'))
print(result)

import operator


def find_answer(data):
    calculate = {1: operator.add, 2: operator.mul}
    lst = data[:]
    for start in range(0, len(lst) + 1, 4):
        opcode, inp_1, inp_2, output = lst[start:start + 4]
        if opcode == 99:
            break
        else:
            lst[output] = calculate[opcode](lst[inp_1], lst[inp_2])

    return lst[0]

import operator
from itertools import permutations


def find_answer(data, target):
    calculate = {1: operator.add, 2: operator.mul}
    for (noun, verb) in permutations(range(100), 2):
        lst = data[:]
        lst[1], lst[2] = noun, verb
        for pointer in range(0, len(lst) + 1, 4):
            opcode, par_1, par_2, par_3 = lst[pointer:pointer+4]
            if opcode == 99:
                break
            else:
                lst[par_3] = calculate[opcode](lst[par_1], lst[par_2])
        if lst[0] == target:
            return noun * 100 + verb

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()