Added working solution for Day 10 part 1

Author: LukeMoll

day10.py

@@ -2,6 +2,8 @@
 from typing import List, Tuple, Set, Dict
 from collections import namedtuple
 import math
+from functools import lru_cache
+from operator import itemgetter
 from pprint import pprint
 
 class Vector(namedtuple('Vector', ['x','y'])):
@@ -13,56 +15,113 @@ def __sub__(self, other):
         assert type(other) == Vector
         return Vector(self.x-other.x, self.y-other.y)
 
+    def __mul__(self, other):
+        assert type(other) == int
+        return Vector(self.x * other, self.y * other)
+
+    def __floordiv__(self, other):
+        assert type(other) == int
+        return Vector(self.x // other, self.y // other)
+
 def main():
     aoc.header("Monitoring Station")
     aoc.run_tests()
 
-    # aoc.output(1, part1)
+    aoc.output(1, part1)
     # aoc.output(2, part2)
 
 def test():
-    
-    inp1 = [
+    def assert_best(inp : List[str], station : Vector, count : int):
+        (ast, edge) = to_points(inp)
+        best = find_best(ast, edge)
+        assert best[0] == station
+        assert count == best[1]
+
+    assert_best([
         ".#..#",
         ".....",
         "#####",
         "....#",
         "...##"
-    ]
-    t = to_points(inp1)
-    print_field({
-        '#': t[0],
-        ".": t[1]
-    }, t[2])
-
-    print(t[2])
-    edge_vectors = set(edges(t[2]))
-    pprint(edge_vectors)
-    print_field({'+' : edge_vectors}, t[2])
-
-    for origin, asteroids in naive_raytrace(t[0],t[1],t[2]):
-        print_field({
-            "*": t[0],
-            "#": asteroids,
-            ".": {origin}
-        },t[2])
-        input()
+    ], Vector(3,4), 8)
+
+    assert_best([
+        "......#.#.",
+        "#..#.#....",
+        "..#######.",
+        ".#.#.###..",
+        ".#..#.....",
+        "..#....#.#",
+        "#..#....#.",
+        ".##.#..###",
+        "##...#..#.",
+        ".#....####"
+    ], Vector(5,8), 33)
+
+    assert_best([
+        "#.#...#.#.",
+        ".###....#.",
+        ".#....#...",
+        "##.#.#.#.#",
+        "....#.#.#.",
+        ".##..###.#",
+        "..#...##..",
+        "..##....##",
+        "......#...",
+        ".####.###."
+    ], Vector(1,2), 35)
+
+    assert_best([
+        ".#..#..###",
+        "####.###.#",
+        "....###.#.",
+        "..###.##.#",
+        "##.##.#.#.",
+        "....###..#",
+        "..#.#..#.#",
+        "#..#.#.###",
+        ".##...##.#",
+        ".....#.#.."
+    ], Vector(6,3), 41)
+
+    assert_best([
+        ".#..##.###...#######",
+        "##.############..##.",
+        ".#.######.########.#",
+        ".###.#######.####.#.",
+        "#####.##.#.##.###.##",
+        "..#####..#.#########",
+        "####################",
+        "#.####....###.#.#.##",
+        "##.#################",
+        "#####.##.###..####..",
+        "..######..##.#######",
+        "####.##.####...##..#",
+        ".#####..#.######.###",
+        "##...#.##########...",
+        "#.##########.#######",
+        ".####.#.###.###.#.##",
+        "....##.##.###..#####",
+        ".#.#.###########.###",
+        "#.#.#.#####.####.###",
+        "###.##.####.##.#..##"
+    ], Vector(11,13), 210)
 
 def part1():
-    pass
+    (asteroids, edge) = to_points(aoc.get_input().readlines())
+    best = find_best(asteroids, edge)
+    return best[1]
 
 def part2():
     pass
 
-def to_points(lines : List[str]) -> Tuple[Set[Vector], Set[Vector], Vector]:
+def to_points(lines : List[str]) -> Tuple[Set[Vector], Vector]:
     edge = Vector(len(lines[-1]) - 1, len(lines) - 1)
     asteroids = set()
-    gaps = set()
     for x in range(edge.x+1):
         for y in range(edge.y+1):
             if      lines[y][x] == "#": asteroids.add(Vector(x,y))
-            elif    lines[y][x] == ".": gaps.add(Vector(x,y))
-    return (asteroids, gaps, edge)
+    return (asteroids, edge)
 
 
 def edges(edge : Vector):
@@ -90,28 +149,50 @@ def rays(origin : Vector, edge : Vector, edge_vectors):
             rays.add(e)
     return rays
 
+@lru_cache
+def rays_fixed(edge : Vector):
+    def it(origin : Vector):
+        for x in range(edge.x + 1):
+            for y in range(edge.y + 1):
+                ray = origin - Vector(x,y)
+                if (g := math.gcd(origin.x - x, origin.y - y)) > 0:
+                    yield(ray // g)
+    rays = set()    
+    rays.update(it(Vector(      0,      0 )))
+    rays.update(it(Vector( edge.x,      0 )))
+    rays.update(it(Vector(      0, edge.y )))
+    rays.update(it(Vector( edge.x, edge.y )))
+    return rays
+
 def trace(origin : Vector, rays: Set[Vector], asteroids : Set[Vector], edge : Vector) -> Set[Vector]:
     for ray in rays:
-        print(f" Tracing along {ray}", end="", flush=True)
+        # print(f" Tracing along {ray}", end="", flush=True)
         p = origin + ray
         while in_field(p, edge):
-            print(".", end="", flush=True)
+            # print(".", end="", flush=True)
             if p in asteroids:
                 yield p
-                print(f"asteroid at {p}")
+                # print(f"asteroid at {p}")
                 break
             p = p + ray
-        print()
-
-def naive_raytrace(asteroids : Set[Vector], gaps : Set[Vector], edge : Vector):
-    edge_vectors = set(edges(edge))
-
-    for gap in gaps:
-        print(f"Tracing from {gap}")
-        r = rays(gap, edge, edge_vectors)
-        print(f" Got rays ({len(r)})")
-        yield gap, trace(gap, r, asteroids, edge)
-
+        # print()
+
+def naive_raytrace(asteroids : Set[Vector], edge : Vector):
+    r = rays_fixed(edge)
+
+    for asteroid in asteroids:
+        # print(f"Tracing from {asteroid}")
+        # print(f" Got rays ({len(r)})")
+        yield asteroid, trace(asteroid, r, asteroids, edge)
+
+def find_best(asteroids : Set[Vector], edge : Vector):
+    return max(
+        map(
+            lambda t: (t[0], len(set(t[1]))),
+            naive_raytrace(asteroids, edge)
+        ),
+        key=itemgetter(1)        
+    )
 
 def print_field(mappings : Dict[str,Set[Vector]], edge : Vector):
     field = [[" "] * (edge.x + 1) for _ in range((edge.y + 1))]