Reproducible solutions

Author: intgrah

.gitignore

@@ -1,4 +1,4 @@
 __pycache__
 .venv
 build
-submission.tar.gz
+submission.zip

build.py

@@ -1,17 +1,16 @@
-from pathlib import Path
-import re
 import sys
-import compress
+from pathlib import Path
 
+import compress
 
 input_dir = Path("solutions")
 output_dir = Path("build")
 
 
-def main():
+def main() -> None:
     if len(sys.argv) > 1:
         task_num = int(sys.argv[1])
-        tasks = [task_num]
+        tasks: list[int] = [task_num]
     else:
         tasks = range(1, 401)
 
@@ -20,22 +19,38 @@ def main():
 
     for i in tasks:
         filename = f"task{i:03d}.py"
-        with open(input_dir / filename, "r", encoding="latin-1") as f:
+        with (input_dir / filename).open(encoding="latin-1") as f:
             content = f.read()
 
-        match = re.search(r"# compression: auto", content)
+        source_content = content.split("\n#")[0]
+        source_bytes = source_content.encode("latin-1")
 
-        content = content.split("\n#")[0]
+        directives: dict[str, str] = {}
+        for line in content.split("\n"):
+            if line.startswith("# ") and ":" in line:
+                key, _, value = line[2:].partition(":")
+                directives[key.strip()] = value.strip()
 
-        if match:
-            source_bytes = content.encode("latin-1")
-            compressed, _ = compress.compress(source_bytes)
+        compression = directives.get("compression")
+
+        if compression == "frozen":
+            huffman_hex = directives.get("huffman", "")
+            if not huffman_hex:
+                print(f"Warning: {filename} has frozen compression but no huffman")
+                output = source_bytes
+            else:
+                output = compress.compress_frozen(source_bytes, huffman_hex)
+            with (output_dir / filename).open("wb") as f:
+                f.write(output)
 
-            with open(output_dir / filename, "wb") as f:
+        elif compression == "auto":
+            compressed, _ = compress.compress(source_bytes)
+            with (output_dir / filename).open("wb") as f:
                 f.write(compressed)
+
         else:
-            with open(output_dir / filename, "w", encoding="latin-1") as f:
-                f.write(content)
+            with (output_dir / filename).open("w", encoding="latin-1") as f:
+                f.write(source_content)
 
 
 if __name__ == "__main__":

common.py

@@ -1,11 +1,9 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
 import importlib.util
 import json
+import warnings
+from dataclasses import dataclass
 from pathlib import Path
 from types import ModuleType
-import warnings
 
 
 @dataclass(frozen=True, slots=True)
@@ -14,7 +12,7 @@ class TestCase:
     output: list[list[int]]
 
     @staticmethod
-    def from_dict(data: dict) -> TestCase:
+    def from_dict(data: dict) -> "TestCase":
         return TestCase(data["input"], data["output"])
 
 
@@ -38,17 +36,17 @@ def all_testcases(self) -> list[TestCase]:
         return self.train + self.test + self.arc_gen
 
     @staticmethod
-    def from_dict(data: dict) -> Task:
+    def from_dict(data: dict) -> "Task":
         train = [TestCase.from_dict(tc) for tc in data["train"]]
         test = [TestCase.from_dict(tc) for tc in data["test"]]
         arc_gen = [TestCase.from_dict(tc) for tc in data["arc-gen"]]
         return Task(train, test, arc_gen)
 
     @staticmethod
-    def load(task_num: int, tasks_dir: Path = Path("tasks")) -> Task:
+    def load(task_num: int, tasks_dir: Path = Path("tasks")) -> "Task":
         task_filename = f"task{task_num:03d}.json"
         task_path = tasks_dir / task_filename
-        with open(task_path) as f:
+        with task_path.open() as f:
             task_data = json.load(f)
         return Task.from_dict(task_data)
 

compress.py

@@ -1,21 +1,35 @@
 import zlib
-
-from reencode import reencode
+from dataclasses import dataclass
 
 import deflate
 import zopfli.zlib
 
+from reencode import Huffman, lz77, reencode
+
+
+@dataclass(frozen=True)
+class CompressionInfo:
+    method: str
+    window: int
+    delimiter: str
+    reencode: bool
 
-ZOPFLI_ITERS = [15, 128]
-LIBDEFLATE_LEVELS = [11, 12]
-ZLIB_LEVELS = [9]
-DELIMS = [b"'", b'"']
-WINDOWS = [-9, -10]
 
+ZOPFLI_ITERS: list[int] = [15, 128]
+LIBDEFLATE_LEVELS: list[int] = [11, 12]
+ZLIB_LEVELS: list[int] = [9]
+DELIMS: list[bytes] = [b"'", b'"']
+WINDOWS: list[int] = [-9, -10]
 
-def sanitize(b_in: bytes, delim: bytes, use_reencode: bool = True) -> bytes:
-    if use_reencode:
-        b_in = reencode(b_in, delim)
+
+def _hoist_import(src: bytes) -> tuple[bytes, bytes]:
+    if src.startswith(b"import"):
+        module = src.split()[1]
+        return src[len(module) + 8 :], b"," + module
+    return src, b""
+
+
+def _sanitize(b_in: bytes, delim: bytes) -> bytes:
     b_out = bytearray()
     for b, b_next in zip(b_in, [*b_in[1:], 0]):
         if b == 0:
@@ -33,74 +47,103 @@ def sanitize(b_in: bytes, delim: bytes, use_reencode: bool = True) -> bytes:
     return bytes(b_out)
 
 
-def compress(src: bytes) -> tuple[bytes, dict]:
-    candidates: list[tuple[bytes, dict]] = []
-
-    # import hoisting: "import zlib,re"
-    hoisted_import = b""
-    if src.startswith(b"import"):
-        module = src.split()[1]
-        hoisted_import = b"," + module
-        src = src[len(module) + 8 :]
-
+def _wrap(deflate_data: bytes, delim: bytes, hoisted: bytes, window: int) -> bytes:
+    sanitized = _sanitize(reencode(deflate_data, delim), delim)
+    window_str = b",~9" if window == -10 else (b",%d" % window if window != 15 else b"")
+    return (
+        b"#coding:L1\nimport zlib"
+        + hoisted
+        + b"\nexec(zlib.decompress(bytes("
+        + delim
+        + sanitized
+        + delim
+        + b',"L1")'
+        + window_str
+        + b"))"
+    )
+
+
+def compress(src: bytes) -> tuple[bytes, CompressionInfo]:
+    src, hoisted = _hoist_import(src)
     compressed_data: list[tuple[bytes, str, int]] = []
 
     for iters in ZOPFLI_ITERS:
-        full_result = zopfli.zlib.compress(
-            src, numiterations=iters, blocksplitting=False
+        full: bytes = zopfli.zlib.compress(
+            src,
+            numiterations=iters,
+            blocksplitting=False,
         )
-        result = full_result[2:-4]
-        actual_window = -(((full_result[0] >> 4) & 0x0F) + 8)
-
+        result = full[2:-4]
+        actual_window = -(((full[0] >> 4) & 0x0F) + 8)
         compressed_data.append((result, f"zopfli(iters={iters})", -10))
         if actual_window != -10:
-            output_window = -9 if actual_window < 15 else actual_window
-            compressed_data.append((result, f"zopfli(iters={iters})", output_window))
-
-    for level in LIBDEFLATE_LEVELS:
-        result = bytes(deflate.deflate_compress(src, compresslevel=level))
-        compressed_data.append((result, f"libdeflate(level={level})", -10))
+            compressed_data.append(
+                (
+                    result,
+                    f"zopfli(iters={iters})",
+                    -9 if actual_window < 15 else actual_window,
+                ),
+            )
+
+    compressed_data.extend(
+        (
+            bytes(deflate.deflate_compress(src, compresslevel=level)),
+            f"libdeflate(level={level})",
+            -10,
+        )
+        for level in LIBDEFLATE_LEVELS
+    )
 
     for level in ZLIB_LEVELS:
         for window in WINDOWS:
-            if window == -10:
-                result = zlib.compress(src, level=level, wbits=-15)[:]
-            else:
-                result = zlib.compress(src, level=level, wbits=window)[:]
+            result = zlib.compress(
+                src,
+                level=level,
+                wbits=-15 if window == -10 else window,
+            )
             compressed_data.append((result, f"zlib(level={level})", window))
 
+    candidates: list[tuple[bytes, CompressionInfo]] = []
     for data, method, window in compressed_data:
         for delim in DELIMS:
             for use_reencode in [True, False]:
-                sanitized = sanitize(data, delim, use_reencode=use_reencode)
-                literal = delim + sanitized + delim
-
+                sanitized = _sanitize(
+                    reencode(data, delim) if use_reencode else data,
+                    delim,
+                )
                 window_str = (
                     b",~9"
                     if window == -10
                     else (b",%d" % window if window != 15 else b"")
                 )
-
                 code = (
                     b"#coding:L1\nimport zlib"
-                    + hoisted_import
+                    + hoisted
                     + b"\nexec(zlib.decompress(bytes("
-                    + literal
+                    + delim
+                    + sanitized
+                    + delim
                     + b',"L1")'
                     + window_str
                     + b"))"
                 )
-
                 candidates.append(
                     (
                         code,
-                        {
-                            "method": method,
-                            "window": window,
-                            "delimiter": delim.decode("latin-1"),
-                            "reencode": use_reencode,
-                        },
-                    )
+                        CompressionInfo(
+                            method=method,
+                            window=window,
+                            delimiter=delim.decode(),
+                            reencode=use_reencode,
+                        ),
+                    ),
                 )
 
     return min(candidates, key=lambda x: len(x[0]))
+
+
+def compress_frozen(src: bytes, huffman_hex: str) -> bytes:
+    src, hoisted = _hoist_import(src)
+    huffman = Huffman.parse(bytes.fromhex(huffman_hex))
+    candidates = [_wrap(lz77(src, huffman, d), d, hoisted, -10) for d in DELIMS]
+    return min(candidates, key=len)

pyproject.toml

@@ -18,3 +18,6 @@ dev = ["ruff>=0.14.3", "ty>=0.0.1a25"]
 
 [tool.ruff]
 exclude = ["solutions", "build"]
+
+[tool.ty.src]
+exclude = ["solutions/", "build/"]