Rename the CoordinatesParser and Map to append a C for complex

IsaacG · IsaacG · commit 9072e12251af · 2025-11-23T11:41:53.000-08:00
diff --git a/advent_of_code/2017/d19.py b/advent_of_code/2017/d19.py
@@ -28,7 +28,7 @@ class Day19(aoc.Challenge):
         aoc.TestCase(part=1, inputs=SAMPLE, want="ABCDEF"),
         aoc.TestCase(part=2, inputs=SAMPLE, want=38),
     ]
-    INPUT_PARSER = aoc.CoordinatesParser(ignore=" ")
+    INPUT_PARSER = aoc.CoordinatesParserC(ignore=" ")
 
     def solver(self, puzzle_input: dict[complex, str], part_one: bool) -> int | str:
         """Walk the maze and track steps/letters."""
diff --git a/advent_of_code/2017/d22.py b/advent_of_code/2017/d22.py
@@ -15,7 +15,7 @@ class Day22(aoc.Challenge):
     INPUT_PARSER = aoc.ParseMultiple(
         [
             aoc.Transform(lambda x: len(x.splitlines())),
-            aoc.CoordinatesParser(origin_top_left=False),
+            aoc.CoordinatesParserC(origin_top_left=False),
         ]
     )
     TESTS = [
diff --git a/advent_of_code/2018/d13.py b/advent_of_code/2018/d13.py
@@ -96,7 +96,7 @@ def solver(self, puzzle_input: InputType, part_one: bool) -> str:
 
     def input_parser(self, puzzle_input: str) -> InputType:
         """Parse the input data."""
-        parsed = aoc.CoordinatesParser().parse(puzzle_input)
+        parsed = aoc.CoordinatesParserC().parse(puzzle_input)
         junctions = parsed.coords.get("+", set())
         turns = {coord: CORNERS[char] for char in "/\\" for coord in parsed.coords.get(char, [])}
         wagons_directions = {coord: direction for char, direction in DIRECTIONS.items() for coord in parsed.coords.get(char, [])}
diff --git a/advent_of_code/2018/d15.py b/advent_of_code/2018/d15.py
@@ -170,7 +170,7 @@ def simulate(self, spaces: set[complex], units_by_type: dict[str, dict[complex,
 
     def input_parser(self, puzzle_input: str) -> InputType:
         """Parse the input data."""
-        data = aoc.CoordinatesParser().parse(puzzle_input)
+        data = aoc.CoordinatesParserC().parse(puzzle_input)
         spaces = data - "#"
         units = {
             unit_type: {
diff --git a/advent_of_code/2018/d18.py b/advent_of_code/2018/d18.py
@@ -27,7 +27,7 @@ class Day18(aoc.Challenge):
         aoc.TestCase(part=1, inputs=SAMPLE, want=1147),
         aoc.TestCase(part=2, inputs=SAMPLE, want=aoc.TEST_SKIP),
     ]
-    INPUT_PARSER = aoc.CoordinatesParser(chars=None, origin_top_left=True)
+    INPUT_PARSER = aoc.CoordinatesParserC(chars=None, origin_top_left=True)
 
     def solver(self, puzzle_input: aoc.Map, part_one: bool) -> int:
         area = typing.cast(frozendict.frozendict[complex, str], frozendict.frozendict(puzzle_input.chars))
diff --git a/advent_of_code/2019/d18.py b/advent_of_code/2019/d18.py
@@ -164,7 +164,7 @@ def solve_for(self, starts: list[str], edges: dict[str, dict[str, tuple[int, int
 
     def solver(self, puzzle_input: str, part_one: bool) -> int:
         if not part_one:
-            data = aoc.CoordinatesParser(ignore=None, origin_top_left=True).parse(puzzle_input)
+            data = aoc.CoordinatesParserC(ignore=None, origin_top_left=True).parse(puzzle_input)
 
             center = data.coords["@"].copy().pop()
             data.update(center, "#")
@@ -177,7 +177,7 @@ def solver(self, puzzle_input: str, part_one: bool) -> int:
                 typing.cast(dict[complex, str], data.chars), data.max_y + 1, data.max_x + 1
             )
 
-        data = aoc.CoordinatesParser(ignore="#", origin_top_left=True).parse(puzzle_input)
+        data = aoc.CoordinatesParserC(ignore="#", origin_top_left=True).parse(puzzle_input)
         starts = list("@" if part_one else "0123")
         nodes: dict[str, complex] = {
             char: pos
diff --git a/advent_of_code/2019/d20.py b/advent_of_code/2019/d20.py
@@ -114,7 +114,7 @@ class Day20(aoc.Challenge):
         aoc.TestCase(part=1, inputs=SAMPLE[1], want=58),
         aoc.TestCase(part=2, inputs=SAMPLE[2], want=396),
     ]
-    INPUT_PARSER = aoc.CoordinatesParser()
+    INPUT_PARSER = aoc.CoordinatesParserC()
 
     def get_portals(self, puzzle_input: aoc.Map, part_one: bool) -> dict[str, list[tuple[complex, int]]]:
         """Return a map of all the portals (their positions and in/out direction)."""
diff --git a/advent_of_code/2021/d09.py b/advent_of_code/2021/d09.py
@@ -20,7 +20,7 @@ class Day09(aoc.Challenge):
         aoc.TestCase(inputs=SAMPLE[0], part=1, want=15),
         aoc.TestCase(inputs=SAMPLE[0], part=2, want=1134),
     )
-    INPUT_PARSER = aoc.CoordinatesParser()
+    INPUT_PARSER = aoc.CoordinatesParserC()
 
     @classmethod
     def lows(cls, depths: aoc.Map) -> list[complex]:
diff --git a/advent_of_code/2021/d15.py b/advent_of_code/2021/d15.py
@@ -55,7 +55,7 @@ def part2(self, puzzle_input: aoc.Map) -> int:
             )
             for y in range(graph.height * 5)
         ]
-        graph = aoc.CoordinatesParser().parse("\n".join(rows))
+        graph = aoc.CoordinatesParserC().parse("\n".join(rows))
         return self.solve(graph)
 
     @staticmethod
diff --git a/advent_of_code/2022/d12.py b/advent_of_code/2022/d12.py
@@ -61,7 +61,7 @@ def part2(self, puzzle_input: InputType) -> int:
 
     def input_parser(self, puzzle_input: str) -> InputType:
         """Parse the input data."""
-        parser = aoc.CoordinatesParser()
+        parser = aoc.CoordinatesParserC()
         data = parser.parse(puzzle_input)
         start = data["S"].pop()
         end = data["E"].pop()
diff --git a/advent_of_code/2022/d17.py b/advent_of_code/2022/d17.py
@@ -41,7 +41,7 @@ class Day17(aoc.Challenge):
     def pre_run(self, puzzle_input: InputType) -> None:
         """Parse the rock shapes from ASCII art."""
         rocks = []
-        parser = aoc.CoordinatesParser()
+        parser = aoc.CoordinatesParserC()
         for block in ROCKS.strip().split("\n\n"):
             block = block.replace(" ", "")
             # Flip rocks upside down so Y increases from the bottom to the top.
diff --git a/advent_of_code/2022/d22.py b/advent_of_code/2022/d22.py
@@ -248,7 +248,7 @@ class Day22(aoc.Challenge):
         aoc.TestCase(inputs=SAMPLE, part=1, want=6032),
         aoc.TestCase(inputs=SAMPLE, part=2, want=5031),
     ]
-    INPUT_PARSER = aoc.ParseBlocks([aoc.CoordinatesParser(), aoc.parse_re_findall_str(r"(L|R|\d+)")])
+    INPUT_PARSER = aoc.ParseBlocks([aoc.CoordinatesParserC(), aoc.parse_re_findall_str(r"(L|R|\d+)")])
 
     def solver(self, puzzle_input: InputType, part_one: bool) -> int:
         """Return the final location after wandering the map."""
diff --git a/advent_of_code/2023/d13.py b/advent_of_code/2023/d13.py
@@ -30,7 +30,7 @@ class Day13(aoc.Challenge):
         aoc.TestCase(inputs=SAMPLE, part=1, want=405),
         aoc.TestCase(inputs=SAMPLE, part=2, want=400),
     ]
-    INPUT_PARSER = aoc.ParseBlocks([aoc.CoordinatesParser()])
+    INPUT_PARSER = aoc.ParseBlocks([aoc.CoordinatesParserC()])
 
     def find_mirror(self, points: set[complex], point: complex | None) -> int | None:
         """Find the row/column around which the data is mirrored.
diff --git a/advent_of_code/2024/d08.py b/advent_of_code/2024/d08.py
@@ -27,7 +27,7 @@ class Day08(aoc.Challenge):
         aoc.TestCase(part=1, inputs=SAMPLE, want=14),
         aoc.TestCase(part=2, inputs=SAMPLE, want=34),
     ]
-    INPUT_PARSER = aoc.CoordinatesParser()
+    INPUT_PARSER = aoc.CoordinatesParserC()
 
     def solver(self, puzzle_input: aoc.Map, part_one: bool) -> int:
         all_locations = puzzle_input.all_coords
diff --git a/advent_of_code/2024/d10.py b/advent_of_code/2024/d10.py
@@ -21,7 +21,7 @@ class Day10(aoc.Challenge):
         aoc.TestCase(part=1, inputs=SAMPLE, want=36),
         aoc.TestCase(part=2, inputs=SAMPLE, want=81),
     ]
-    INPUT_PARSER = aoc.CoordinatesParser()
+    INPUT_PARSER = aoc.CoordinatesParserC()
 
     def solver(self, puzzle_input: aoc.Map, part_one: bool) -> int:
         """Score and rate trails by computing how to walk the trail to a 9."""
diff --git a/advent_of_code/2024/d15.py b/advent_of_code/2024/d15.py
@@ -62,7 +62,7 @@ class Day15(aoc.Challenge):
 
     def part1(self, puzzle_input: str) -> int:
         board, instructions = aoc.ParseBlocks(
-            [aoc.CoordinatesParser(), aoc.parse_one_str]).parse(puzzle_input)
+            [aoc.CoordinatesParserC(), aoc.parse_one_str]).parse(puzzle_input)
         robot = board["@"].pop()
         walls, boxes = board["#O"]
         directions = (aoc.ARROW_DIRECTIONS[i] for i in instructions.replace("\n", ""))
@@ -85,7 +85,7 @@ def part2(self, puzzle_input: str) -> int:
         for find, replace in [("#", "##"), ("O", "[]"), (".", ".."), ("@", "@.")]:
             puzzle_input = puzzle_input.replace(find, replace)
         board, instructions = aoc.ParseBlocks(
-            [aoc.CoordinatesParser(), aoc.parse_one_str]).parse(puzzle_input)
+            [aoc.CoordinatesParserC(), aoc.parse_one_str]).parse(puzzle_input)
         robot = board["@"].pop()
         walls, boxes = board["#["]
 
diff --git a/advent_of_code/2024/d25.py b/advent_of_code/2024/d25.py
@@ -53,7 +53,7 @@ class Day25(aoc.Challenge):
         aoc.TestCase(part=1, inputs=SAMPLE, want=3),
         aoc.TestCase(part=2, inputs=SAMPLE, want=aoc.TEST_SKIP),
     ]
-    INPUT_PARSER = aoc.ParseBlocks([aoc.CoordinatesParser()])
+    INPUT_PARSER = aoc.ParseBlocks([aoc.CoordinatesParserC()])
 
     def part1(self, puzzle_input: list[aoc.Map]) -> int:
         """Count how many keys (loosely) fit inside a locks."""
diff --git a/pylib/helpers.py b/pylib/helpers.py
@@ -150,7 +150,7 @@ def t_neighbors4(point: collections.abc.Sequence[int]) -> collections.abc.Iterab
 
 
 @dataclasses.dataclass
-class Map:
+class MapC:
     max_x: int
     max_y: int
     chars: dict[complex, str | int]
@@ -215,6 +215,68 @@ def neighbors(self, point: complex, directions: collections.abc.Sequence[complex
         return {n: self.chars[n] for n in neighbors(point, directions) if n in self.all_coords}
 
 
+@dataclasses.dataclass
+class Map:
+    max_x: int
+    max_y: int
+    chars: dict[tuple[int, int], str | int]
+    coords: dict[str | int, set[tuple[int, int]]]
+    all_coords: set[tuple[int, int]]
+    blank_char: str
+    non_blank_chars: set[str]
+
+    def __post_init__(self) -> None:
+        self.width = self.max_x + 1
+        self.height = self.max_y + 1
+
+    def __sub__(self, key: str) -> set[tuple[int, int]]:
+        return self.all_coords - self[key]
+
+    def __contains__(self, item) -> bool:
+        if not isinstance(item, tuple[int, int]):
+            raise TypeError(f"contains not defined for {type(item)}")
+        return item in self.all_coords
+
+    def __getitem__(self, key: str | tuple[int, int]) -> str | int | set[tuple[int, int]] | list[set[tuple[int, int]]]:
+        if isinstance(key, tuple[int, int]):
+            return self.chars[key]
+        if isinstance(key, int):
+            return self.coords[key]
+        if isinstance(key, str) and len(key) == 1:
+            return self.coords[key]
+        if isinstance(key, collections.abc.Sequence):
+            return [self.coords[k] for k in key]
+        raise ValueError(f"Could not index on {key}")
+
+    @property
+    def size(self) -> int:
+        if self.max_x != self.max_y:
+            raise ValueError(f"The input is {self.width, self.height} and not square!")
+        return self.width
+
+    def update(self, coord: tuple[int, int], val: int | str) -> None:
+        prior = self.chars[coord]
+        self.chars[coord] = val
+        self.coords[prior].remove(coord)
+        self.coords.setdefault(val, set()).add(coord)
+
+    def get_coords(self, chars: collections.abc.Iterable[str]) -> list[set[tuple[int, int]]]:
+        return [self.coords[char] for char in chars]
+
+    @property
+    def corners(self) -> tuple[tuple[int, int], tuple[int, int], tuple[int, int], tuple[int, int]]:
+        return (
+            0,
+            (0, self.max_y),
+            (self.max_x, 0),
+            (self.max_x, self.max_y)
+        )
+
+    def neighbors(self, point: tuple[int, int], directions: collections.abc.Sequence[tuple[int, int]] = STRAIGHT_NEIGHBORS) -> dict[tuple[int, int], T]:
+        """Return neighboring points and values which are in the map."""
+        return {n: self.chars[n] for n in neighbors(point, directions) if n in self.all_coords}
+
+
 def render_char_map(chars: dict[complex, str], height: int, width: int) -> str:
     """Render the map as a string."""
     lines = []
diff --git a/pylib/parsers.py b/pylib/parsers.py
@@ -248,7 +248,7 @@ def parse(self, puzzle_input: Any) -> Any:
 
 
 @dataclasses.dataclass
-class CoordinatesParser(BaseParser):
+class CoordinatesParserC(BaseParser):
     """Generate coordinate sets for multiple characters."""
 
     chars: collections.abc.Iterable[str] | None = None
@@ -289,6 +289,59 @@ def parse(self, puzzle_input: str) -> Map:
         blank_char = max(coords_by_char, key=lambda x: len(coords_by_char[x]))
         non_blank_chars = set(coords_by_char) - {blank_char}
 
+        return MapC(
+            max_x=x,
+            max_y=y,
+            chars=char_by_coord,
+            coords=dict(coords_by_char),
+            all_coords=all_coords,
+            blank_char=blank_char,
+            non_blank_chars=non_blank_chars,
+        )
+
+
+@dataclasses.dataclass
+class CoordinatesParser(BaseParser):
+    """Generate coordinate sets for multiple characters."""
+
+    chars: collections.abc.Iterable[str] | None = None
+    origin_top_left: bool = True
+    ignore: str | None = None
+
+    def parse(self, puzzle_input: str) -> Map:
+        """Parse a map and return the coordinates of different chars."""
+        lines = puzzle_input.splitlines()
+
+        if not self.origin_top_left:
+            lines.reverse()
+
+        x, y = (len(lines[0]), len(lines))
+
+        all_chars = set(i for line in lines for i in line)
+        want_chars = set(self.chars) if self.chars else all_chars
+        if self.ignore:
+            want_chars -= set(self.ignore)
+        transform: Callable[[str], str | int]
+        if all(i.isdigit() for i in all_chars):
+            transform = int
+        else:
+            transform = str
+
+        coords_by_char = collections.defaultdict(set)
+        char_by_coord = {}
+        all_coords = set()
+        for y, line in enumerate(lines):
+            for x, char in enumerate(line):
+                if char not in want_chars:
+                    continue
+                pos = (x, y)
+                all_coords.add(pos)
+                coords_by_char[transform(char)].add(pos)
+                char_by_coord[pos] = transform(char)
+
+        blank_char = max(coords_by_char, key=lambda x: len(coords_by_char[x]))
+        non_blank_chars = set(coords_by_char) - {blank_char}
+
         return Map(
             max_x=x,
             max_y=y,

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ class Day19(aoc.Challenge):`
`28`	`28`	`aoc.TestCase(part=1, inputs=SAMPLE, want="ABCDEF"),`
`29`	`29`	`aoc.TestCase(part=2, inputs=SAMPLE, want=38),`
`30`	`30`	`]`
`31`		`- INPUT_PARSER = aoc.CoordinatesParser(ignore=" ")`
	`31`	`+ INPUT_PARSER = aoc.CoordinatesParserC(ignore=" ")`
`32`	`32`
`33`	`33`	`def solver(self, puzzle_input: dict[complex, str], part_one: bool) -> int \| str:`
`34`	`34`	`"""Walk the maze and track steps/letters."""`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ class Day22(aoc.Challenge):`
`15`	`15`	`INPUT_PARSER = aoc.ParseMultiple(`
`16`	`16`	`[`
`17`	`17`	`aoc.Transform(lambda x: len(x.splitlines())),`
`18`		`- aoc.CoordinatesParser(origin_top_left=False),`
	`18`	`+ aoc.CoordinatesParserC(origin_top_left=False),`
`19`	`19`	`]`
`20`	`20`	`)`
`21`	`21`	`TESTS = [`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ class Day18(aoc.Challenge):`
`27`	`27`	`aoc.TestCase(part=1, inputs=SAMPLE, want=1147),`
`28`	`28`	`aoc.TestCase(part=2, inputs=SAMPLE, want=aoc.TEST_SKIP),`
`29`	`29`	`]`
`30`		`- INPUT_PARSER = aoc.CoordinatesParser(chars=None, origin_top_left=True)`
	`30`	`+ INPUT_PARSER = aoc.CoordinatesParserC(chars=None, origin_top_left=True)`
`31`	`31`
`32`	`32`	`def solver(self, puzzle_input: aoc.Map, part_one: bool) -> int:`
`33`	`33`	`area = typing.cast(frozendict.frozendict[complex, str], frozendict.frozendict(puzzle_input.chars))`
Original file line number	Diff line number	Diff line change
`@@ -114,7 +114,7 @@ class Day20(aoc.Challenge):`
`114`	`114`	`aoc.TestCase(part=1, inputs=SAMPLE[1], want=58),`
`115`	`115`	`aoc.TestCase(part=2, inputs=SAMPLE[2], want=396),`
`116`	`116`	`]`
`117`		`- INPUT_PARSER = aoc.CoordinatesParser()`
	`117`	`+ INPUT_PARSER = aoc.CoordinatesParserC()`
`118`	`118`
`119`	`119`	`def get_portals(self, puzzle_input: aoc.Map, part_one: bool) -> dict[str, list[tuple[complex, int]]]:`
`120`	`120`	`"""Return a map of all the portals (their positions and in/out direction)."""`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ class Day09(aoc.Challenge):`
`20`	`20`	`aoc.TestCase(inputs=SAMPLE[0], part=1, want=15),`
`21`	`21`	`aoc.TestCase(inputs=SAMPLE[0], part=2, want=1134),`
`22`	`22`	`)`
`23`		`- INPUT_PARSER = aoc.CoordinatesParser()`
	`23`	`+ INPUT_PARSER = aoc.CoordinatesParserC()`
`24`	`24`
`25`	`25`	`@classmethod`
`26`	`26`	`def lows(cls, depths: aoc.Map) -> list[complex]:`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ def part2(self, puzzle_input: aoc.Map) -> int:`
`55`	`55`	`)`
`56`	`56`	`for y in range(graph.height * 5)`
`57`	`57`	`]`
`58`		`- graph = aoc.CoordinatesParser().parse("\n".join(rows))`
	`58`	`+ graph = aoc.CoordinatesParserC().parse("\n".join(rows))`
`59`	`59`	`return self.solve(graph)`
`60`	`60`
`61`	`61`	`@staticmethod`