Everybody Codes: tidy 2025/06

Author: IsaacG

everybody_codes/event2025/quest_06.py

@@ -1,84 +1,46 @@
 """Everyone Codes Day N."""
 
 import collections
-import logging
-import itertools
 import math
-from lib import parsers
+import time
 
-log = logging.info
 
 def solve(part: int, data: str) -> int:
     """Solve the parts."""
-    total = 0
     if part in [1, 2]:
-        counts = collections.defaultdict(int)
+        total = 0
+        counts: dict[str, int] = collections.defaultdict(int)
         for i in data:
             if i.isupper():
                 counts[i.lower()] += 1
             else:
-                if (i == "a" and part == 1) or part == 2:
+                if i == "a" or part == 2:
                     total += counts[i]
         return total
 
-    l = len(data)
-    window = collections.deque()
-    mentors = collections.defaultdict(int)
-    for i in range(1000):
-        j = data[i % l]
-        window.append(j)
-        if j.isupper():
-            mentors[j.lower()] += 1
-
-    limit = 1000 * (l - 1)
-    for idx, n in enumerate(j for i in range(1000) for j in data):
-        if idx > 1000:
-            j = window.popleft()
-            if j.isupper():
-                mentors[j.lower()] -= 1
-        j = data[(idx + 1000) % l] if idx < limit else " "
-        window.append(j)
-        if j.isupper():
-            mentors[j.lower()] += 1
-        if n.islower():
-            total += mentors[n]
-
-    return total
-
-
-
-
-    once  = math.ceil(1000 / len(data))
+    # Part three.
+    # Number of repeated needed to get to 1000 characters.
+    once = math.ceil(1000 / len(data))
     twice = once * 2
-    three = once * 3
+    repeats = 1000 - twice
 
-    mentors = collections.defaultdict(set)
-    for idx, m in enumerate(j for i in range(twice) for j in data):
-        if m.isupper():
-            mentors[m.lower()].add(idx)
-    
-    edges = 0
-    for idx, m in enumerate(j for i in range(twice) for j in data):
-        if m.islower():
-            for i in mentors[m.lower()]:
-                if abs(idx - i) <= 1000:
-                    edges += 1
-
-    mentors = collections.defaultdict(set)
-    for idx, m in enumerate(j for i in range(three) for j in data):
-        if m.isupper():
-            mentors[m.lower()].add(idx)
-    
-    middle = 0
-    count = 1000 - twice
+    total = 0
+    # Repeat the data enough to have a look behind and look ahead of 1000.
+    # Compute the middle portion for one repetition then multiple it.
+    d = data * (twice + 1)
+    shift = len(data) * once
     for idx, m in enumerate(data):
         if m.islower():
-            for i in mentors[m.lower()]:
-                if abs(idx + once * len(data) - i) <= 1000:
-                    middle += 1
+            total += d[shift + idx - 1000:shift + idx + 1001].count(m.upper())
+    total *= repeats
 
-    return edges + middle * count
+    # Handle the edges where there is not a full 1000 ahead or behind.
+    d = data * twice
+    for idx, m in enumerate(j for i in range(twice) for j in data):
+        if m.islower():
+            total += d[max(idx - 1000, 0):idx + 1001].count(m.upper())
 
+    return total
 
 
 TESTS = [
@@ -94,4 +56,7 @@ def solve(part: int, data: str) -> int:
     day = __file__.split("_", maxsplit=-1)[-1].split(".")[0]
     for _part in range(1, 4):
         with open(f"inputs/{day}.{_part}.txt", encoding="utf-8") as f:
-            print(_part, solve(_part, (f.read())))
+            start = time.perf_counter_ns()
+            got = solve(_part, (f.read()))
+            end = time.perf_counter_ns()
+            print(_part, got, (end - start) / 1_000_000_000)

pylib/running.py

@@ -89,6 +89,22 @@ def input_data(self, part: int) -> str | None:
             return None
         return data_path.read_text().rstrip()
 
+    def compare(self, want, data: str, parser: typing.Callable, msg_success: str, msg_fail: str, func: typing.Callable, **kwargs):
+        if parser:
+            data = parser(data)
+        time_s, got = helpers.timed(func, data=data, **kwargs)
+        if str(got) == str(want):
+            print(msg_success % time_s)
+        else:
+            msg = msg_fail % (time_s, got)
+            if str(want).isdigit() and str(got).isdigit():
+                delta = int(want) - int(got)
+                if delta > 0:
+                    msg += f" Too low by {delta}."
+                else:
+                    msg += f" Too high by {-delta}."
+            print(msg)
+
     def run_day(self, check: bool, solve: bool, test: bool, formatter) -> None:
         solution_file = pathlib.Path(f"{self.year}/{self.module_name()}.py")
         if not solution_file.exists():
@@ -100,15 +116,15 @@ def run_day(self, check: bool, solve: bool, test: bool, formatter) -> None:
             for part in self.parts:
                 formatter.set_part(part)
                 for test_number, (test_part, test_data, test_want) in enumerate(module.TESTS, 1):
-                    if parser:
-                        test_data = parser(test_data)
                     if test_part != part:
                         continue
-                    time_s, got = helpers.timed(module.solve, part=part, data=test_data, testing=True, test_number=test_number)
-                    if got == test_want:
-                        print(f"TEST  {self.day:02}.{part} {time_s} PASS (test {test_number})")
-                    else:
-                        print(f"TEST  {self.day:02}.{part} {time_s} FAIL (test {test_number}). Got {got} but wants {test_want}.")
+                    self.compare(
+                        test_want, test_data, parser,
+                        f"TEST  {self.day:02}.{part} %s PASS (test {test_number})",
+                        f"TEST  {self.day:02}.{part} %s FAIL (test {test_number}). Got %r but wants {test_want!r}.",
+                        module.solve,
+                        part=part, testing=True, test_number=test_number,
+                    )
         if solve:
             for part in self.parts:
                 formatter.set_part(part)
@@ -131,14 +147,13 @@ def run_day(self, check: bool, solve: bool, test: bool, formatter) -> None:
                     if data is None:
                         print(f"CHECK No input data found for day {day} part {part}")
                         continue
-                    if parser:
-                        data = parser(data)
-                    time_s, got = helpers.timed(module.solve, part=part, data=data, testing=False, test_number=None)
-                    if str(got) == want[part - 1]:
-                        print(f"CHECK {self.day:02}.{part} {time_s} PASS")
-                    else:
-                        print(f"CHECK {self.day:02}.{part} {time_s} FAIL. Wanted {want[part -1]} but got {got}.")
-
+                    self.compare(
+                        want[part - 1], data, parser,
+                        f"CHECK {self.day:02}.{part} %s PASS",
+                        f"CHECK {self.day:02}.{part} %s FAIL. Wanted {want[part -1]} but got %s.",
+                        module.solve,
+                        part=part, testing=False, test_number=None,
+                    )
 
     def run(self, check: bool, solve: bool, test: bool, live: bool) -> None:
         formatter = helpers.setup_logging(self.day, self.verbose)