Day 6

day06-1.py

+import argparse
+import enum
+import logging
+
+from sys import stdout
+from typing import List, Tuple
+
+logger = logging.Logger(__name__)
+logger_2 = logging.Logger(f"{__name__}_2")
+formatter = logging.Formatter('[%(asctime)s][%(levelname)s] %(message)s')
+sh = logging.StreamHandler(stdout)
+sh.setLevel(logging.INFO)
+sh.setFormatter(formatter)
+fh = logging.FileHandler("./day02-2.log", mode="w", encoding="utf-8")
+fh_2 = logging.FileHandler("./day02-2_round2.log", mode="w", encoding="utf-8")
+fh.setLevel(logging.DEBUG)
+fh.setFormatter(formatter)
+fh_2.setLevel(logging.DEBUG)
+fh_2.setFormatter(formatter)
+logger.addHandler(sh)
+logger.addHandler(fh)
+logger_2.addHandler(fh_2)
+
+class Direction(enum.Enum):
+    UP = 0
+    RIGHT = 1
+    DOWN = 2
+    LEFT = 3
+
+class Guard:
+    def __init__(self, grid: List[List[str]], initial_x: int = None, initial_y: int = None, initial_dir: int = None, test_mode: bool = False) -> object:
+        self.grid = grid
+        self.height = len(self.grid)
+        self.width = len(self.grid[0])
+        logger.info(f"Received a grid with {self.height} lines and {self.width} characters per line.")
+        self.initial_x = initial_x
+        self.x = self.initial_x
+        self.initial_y = initial_y
+        self.y = self.initial_y
+        self.initial_dir = initial_dir
+        self.dir = self.initial_dir
+        self.test_mode = test_mode
+        self.visited = set()
+        self.traveled = 1
+
+    def whereami(self) -> Tuple[int,int]:
+        # Identify the guard's initial position and direction in the grid
+        breakout = False
+        x,y,dir = None,None,None
+        for j, line in enumerate(self.grid):
+            if breakout:
+                break
+            for i, char in enumerate(line):
+                if char in ["^",">","<","v"]:
+                    x, y = i, j
+                    match char:
+                        case "^":
+                            dir = Direction.UP
+                        case ">":
+                            dir = Direction.RIGHT
+                        case "v":
+                            dir = Direction.DOWN
+                        case "<":
+                            dir = Direction.LEFT
+                        case "_":
+                            raise ValueError(f"char must be one of '^','>','v','<', received {char}")
+                    breakout = True
+                    break
+        
+        self.initial_x = x
+        self.x = self.initial_x
+        self.initial_y = y
+        self.y = self.initial_y
+        self.initial_dir = dir
+        self.dir = self.initial_dir
+
+        return (x,y)
+
+    def proceed(self):
+        if self.dir is None:
+            logger.error("You can't move until you have a direction set.")
+            raise ValueError
+        logger.info(f"Proceeding {self.dir}")
+        match self.dir:
+            case Direction.UP:
+                return self.go_north()
+            case Direction.RIGHT:
+                return self.go_east()
+            case Direction.DOWN:
+                return self.go_south()
+            case Direction.LEFT:
+                return self.go_west()
+            case _:
+                logger.error(f"Unknown direction! {self.dir}")
+                raise ValueError
+            
+    def go_north(self) -> bool:
+        path = [self.grid[y][self.x] for y in range(self.y-1, -1, -1)]
+        logger.info(f"Path created from {self.x},{self.y} to {self.x},{0}: {path}.")
+        exited = "#" not in path
+        if exited:
+            blocked = 999999
+        else:
+            blocked = path.index("#")
+            if self.test_mode:
+                logger.info(f"Found a blocker at ({self.x}, {self.y-blocked-1}).")
+        for i, char in enumerate(path[:blocked+1]):
+            j = i + 1 if exited else i
+            if self.test_mode:
+                logger.info(f"Walked to ({self.x}, {self.y-j}).")
+            self.visited.add((self.x, self.y-j))
+            self.traveled += 1
+        new_y = self.y - (blocked)
+        self.y = new_y
+        self.dir = Direction.RIGHT
+        return exited
+    
+    def go_east(self) -> bool:
+        path = [self.grid[self.y][x] for x in range(self.x+1, self.width)]
+        logger.info(f"Path created from {self.x},{self.y} to {self.width-1},{self.y}: {path}.")
+        exited = "#" not in path
+        if exited:
+            blocked = 999999
+        else:
+            blocked = path.index("#")
+            if self.test_mode:
+                logger.info(f"Found a blocker at ({self.x+blocked+1}, {self.y}).")
+        for i, char in enumerate(path[:blocked+1]):
+            j = i + 1 if exited else i
+            if self.test_mode:
+                logger.info(f"Walked to ({self.x+j}, {self.y}).")
+            self.visited.add((self.x+j, self.y))
+            self.traveled += 1
+        new_x = self.x + (blocked)
+        self.x = new_x
+        self.dir = Direction.DOWN
+        return exited
+    
+    def go_south(self) -> bool:
+        path = [self.grid[y][self.x] for y in range(self.y+1, self.height)]
+        logger.info(f"Path created from {self.x},{self.y} to {self.x},{self.height}: {path}.")
+        exited = "#" not in path
+        if exited:
+            blocked = 999999
+        else:
+            blocked = path.index("#")
+            if self.test_mode:
+                logger.info(f"Found a blocker at ({self.x}, {self.y+blocked+1}).")
+        for i, char in enumerate(path[:blocked+1]):
+            j = i + 1 if exited else i
+            if self.test_mode:
+                logger.info(f"Walked to ({self.x}, {self.y+j}).")
+            self.visited.add((self.x, self.y+j))
+            self.traveled += 1
+        new_y = self.y + (blocked)
+        self.y = new_y
+        self.dir = Direction.LEFT
+        return exited
+    
+    def go_west(self) -> bool:
+        path = [self.grid[self.y][x] for x in range(self.x-1, -1, -1)]
+        logger.info(f"Path created from {self.x},{self.y} to {0},{self.y}: {path}.")
+        exited = "#" not in path
+        if exited:
+            blocked = 999999
+        else:
+            blocked = path.index("#")
+            if self.test_mode:
+                logger.info(f"Found a blocker at ({self.x-blocked-1}, {self.y}).")
+        for i, char in enumerate(path[:blocked+1]):
+            j = i + 1 if exited else i
+            if self.test_mode:
+                logger.info(f"Walked to ({self.x-j}, {self.y}).")
+            self.visited.add((self.x-j, self.y))
+            self.traveled += 1
+        new_x = self.x - (blocked)
+        self.x = new_x
+        self.dir = Direction.UP
+        return exited
+    
+    def pathfind(self):
+        exited = False
+        while not exited:
+            exited = self.proceed()
+        logger.info(f"Found an exit after {self.traveled} steps!")
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--test", action="store_true", help="Do a test run instead of the full puzzle")
+
+def main061():
+    args = parser.parse_args()
+    if args.test:
+        input_grid = """....#.....
+.........#
+..........
+..#.......
+.......#..
+..........
+.#..^.....
+........#.
+#.........
+......#..."""
+        grid = [list(l) for l in input_grid.split("\n")]
+        print("\n".join(["".join(line) for line in grid]))
+    else:
+        with open("input06.txt", "r", encoding="utf-8") as f:
+            grid = [list(l) for l in f.readlines()]
+
+    guard = Guard(grid, test_mode=args.test)
+    logger.info(f"Guard has been created: x:{guard.x}, y:{guard.y}, dir:{guard.dir}, test_mode:{guard.test_mode}, width:{guard.width}, height:{guard.height}.")
+    guard_position = guard.whereami()
+    logger.info(f"Starting guard's walk at {guard_position}.")
+    guard.pathfind()
+    logger.info(f"The guard visited {len(guard.visited)} unique positions.")
+
+
+if __name__ == "__main__":
+    main061()