Added some utilities

1 files changed, 26 insertions, 44 deletions

diff --git a/day9/__init__.py b/day9/__init__.py
index e0f1d61..a2d6d82 100644
--- a/day9/__init__.py
+++ b/day9/__init__.py
@@ -1,36 +1,10 @@
 # -*- coding: utf-8 -*-
 from abc import ABC
 from copy import copy
-from dataclasses import dataclass
 from typing import Tuple, Iterator, List, Set
 
 from aoc import BaseAssignment
-
-
-@dataclass
-class Coordinate:
-    x: int
-    y: int
-
-    def __hash__(self):
-        return tuple([self.x, self.y]).__hash__()
-
-    def __sub__(self, other: "Coordinate"):
-        return Coordinate(self.x - other.x, self.y - other.y)
-
-    @property
-    def polarity_x(self):
-        try:
-            return abs(self.x) / self.x
-        except ZeroDivisionError:
-            return 0
-
-    @property
-    def polarity_y(self):
-        try:
-            return abs(self.y) / self.y
-        except ZeroDivisionError:
-            return 0
+from aoc.datastructures import Coordinate
 
 
 class Assignment(BaseAssignment, ABC):
@@ -44,36 +18,44 @@ class Assignment(BaseAssignment, ABC):
         pass
 
     @staticmethod
-    def next_head(head: Coordinate, direction: str):
+    def next_head(head: Coordinate, direction: str) -> Coordinate:
         match direction:
             case "R":
-                head.x += 1
+                return head + Coordinate(1, 0)
             case "L":
-                head.x -= 1
+                return head + Coordinate(-1, 0)
             case "U":
-                head.y += 1
+                return head + Coordinate(0, 1)
             case "D":
-                head.y -= 1
+                return head + Coordinate(0, -1)
 
     @staticmethod
-    def next_knot(head: Coordinate, tail: Coordinate):
+    def next_knot(head: Coordinate, tail: Coordinate) -> Coordinate:
         delta = head - tail
 
         if abs(delta.x) < 2 and abs(delta.y) < 2:
-            pass
+            return tail
         elif abs(delta.x) > 1 and delta.y == 0:
-            tail.x += delta.x - delta.polarity_x
+            return tail + Coordinate(
+                delta.x - delta.polarity_x,
+                0,
+            )
         elif abs(delta.x) > 1 and abs(delta.y) == 1:
-            tail.x += delta.x - delta.polarity_x
-            tail.y += delta.y
+            return tail + Coordinate(delta.x - delta.polarity_x, delta.y)
         elif abs(delta.y) > 1 and delta.x == 0:
-            tail.y += delta.y - delta.polarity_y
+            return tail + Coordinate(
+                0,
+                delta.y - delta.polarity_y,
+            )
         elif abs(delta.y) > 1 and abs(delta.x) == 1:
-            tail.y += delta.y - delta.polarity_y
-            tail.x += delta.x
+            return tail + Coordinate(
+                delta.x,
+                delta.y - delta.polarity_y,
+            )
         elif abs(delta.x) > 1 and abs(delta.y) > 1:
-            tail.x += delta.x - delta.polarity_x
-            tail.y += delta.y - delta.polarity_y
+            return tail + Coordinate(
+                delta.x - delta.polarity_x, delta.y - delta.polarity_y
+            )
 
     def tail_positions(self, input: Iterator[str], length: int) -> Iterator[Coordinate]:
         knots = [Coordinate(0, 0) for _ in range(length)]
@@ -84,10 +66,10 @@ class Assignment(BaseAssignment, ABC):
             for _ in range(amount):
                 for index in range(length):
                     if index == 0:
-                        self.next_head(knots[index], direction)
+                        knots[0] = self.next_head(knots[0], direction)
                         continue
 
-                    self.next_knot(knots[index - 1], knots[index])
+                    knots[index] = self.next_knot(knots[index - 1], knots[index])
 
                 yield knots[length - 1]