Use root minify.py and fix test file path in injector

Author: adamant-pwn

.github/workflows/verify.yml

@@ -46,6 +46,7 @@ jobs:
           # Specify patterns
           exclude: |
                 images/
+               .verify-helper/scripts/
           # If you have config.toml
           config: .verify-helper/config.toml
       - name: parse-doxygen

.verify-helper/scripts/inject_minified_docs.py

@@ -33,7 +33,7 @@ def minify_code(code):
     """Minify C++ code on-the-fly using the minify utility."""
     try:
         result = subprocess.run(
-            ['python3', 'cp-algo/util/minify.py'],
+            ['python3', 'cp-algo/minify.py'],
             input=code,
             capture_output=True,
             text=True,
@@ -145,6 +145,8 @@ def main():
     markdown_dir = Path('_jekyll')
     minified_dir = Path('cp-algo/min')
     minified_bundled_dir = Path('.competitive-verifier/minified-bundled')
+    # Repository root (script is in .verify-helper/scripts/)
+    repo_root = Path(__file__).resolve().parents[2]
 
     # If _jekyll doesn't exist, try the verify-helper path (for local testing)
     if not markdown_dir.exists():
@@ -200,7 +202,7 @@ def main():
             # Reconstruct source file path - test files are relative to repo root
             if original_ext:
                 # path_without_ext is like "verify/test_file", we need the actual file in the repo
-                source_file = docs_root.parent / (path_without_ext + original_ext)
+                source_file = repo_root / (path_without_ext + original_ext)
                 if source_file.exists():
                     # Generate bundled+minified version only
                     minified_bundled_code = bundle_and_minify(source_file)

cp-algo/minify.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""
+Simple C++ code minifier for competitive programming.
+Removes comments, extra whitespace, and compresses the code.
+"""
+
+import re
+import sys
+
+def minify_cpp(code):
+    # Remove comments while preserving strings
+    lines = code.split('\n')
+    cleaned_lines = []
+    
+    for line in lines:
+        # Remove single-line comments, but not if // is inside a string
+        in_string = False
+        escape_next = False
+        result = []
+        i = 0
+        
+        while i < len(line):
+            if escape_next:
+                result.append(line[i])
+                escape_next = False
+                i += 1
+                continue
+            
+            if line[i] == '\\' and in_string:
+                result.append(line[i])
+                escape_next = True
+                i += 1
+                continue
+            
+            if line[i] == '"':
+                result.append(line[i])
+                in_string = not in_string
+                i += 1
+                continue
+            
+            if not in_string and i + 1 < len(line) and line[i:i+2] == '//':
+                # Found comment outside string, discard rest of line
+                break
+            
+            result.append(line[i])
+            i += 1
+        
+        cleaned_lines.append(''.join(result))
+    
+    code = '\n'.join(cleaned_lines)
+    
+    # Remove multi-line comments (but preserve #line directives content)
+    code = re.sub(r'/\*.*?\*/', '', code, flags=re.DOTALL)
+    
+    # Remove empty lines
+    code = re.sub(r'\n\s*\n', '\n', code)
+    
+    # Remove leading/trailing whitespace on each line
+    lines = [line.strip() for line in code.split('\n')]
+    
+    # Keep preprocessor directives on their own lines
+    result = []
+    for line in lines:
+        if line.startswith('#'):
+            result.append(line)
+        elif line:
+            result.append(line)
+    
+    code = '\n'.join(result)
+    
+    # Compress spaces (but not in preprocessor directives or strings)
+    def compress_line(line):
+        if line.startswith('#'):
+            return line
+        
+        # Split by string literals while keeping them
+        result = []
+        current = []
+        i = 0
+        
+        while i < len(line):
+            if line[i] == '"':
+                # Found start of string - save accumulated code
+                if current:
+                    code_part = ''.join(current)
+                    # Compress the code part
+                    code_part = re.sub(r'\s+', ' ', code_part)
+                    code_part = re.sub(r'\s*([+\-*/%=<>!&|^~,;:?(){}[\]])\s*', r'\1', code_part)
+                    result.append(code_part)
+                    current = []
+                
+                # Now collect the entire string literal
+                string_chars = ['"']
+                i += 1
+                while i < len(line):
+                    if line[i] == '\\' and i + 1 < len(line):
+                        # Escape sequence
+                        string_chars.append(line[i])
+                        string_chars.append(line[i + 1])
+                        i += 2
+                    elif line[i] == '"':
+                        # End of string
+                        string_chars.append('"')
+                        i += 1
+                        break
+                    else:
+                        string_chars.append(line[i])
+                        i += 1
+                
+                # Keep string literal as-is
+                result.append(''.join(string_chars))
+            else:
+                current.append(line[i])
+                i += 1
+        
+        # Handle any remaining code
+        if current:
+            code_part = ''.join(current)
+            code_part = re.sub(r'\s+', ' ', code_part)
+            code_part = re.sub(r'\s*([+\-*/%=<>!&|^~,;:?(){}[\]])\s*', r'\1', code_part)
+            result.append(code_part)
+        
+        return ''.join(result)
+    
+    lines = [compress_line(line) for line in code.split('\n')]
+    
+    # Join lines intelligently: keep preprocessor directives on their own lines,
+    # and keep a newline after them
+    result_lines = []
+    for i, line in enumerate(lines):
+        if not line:
+            continue
+        
+        if line.startswith('#'):
+            # Preprocessor directive - always on its own line
+            result_lines.append(line)
+        else:
+            # Regular code - try to join with previous line if possible
+            if result_lines and not result_lines[-1].startswith('#'):
+                # Previous line is not a preprocessor directive, can join
+                result_lines[-1] += line
+            else:
+                # Previous line is a preprocessor directive or this is first line
+                result_lines.append(line)
+    
+    code = '\n'.join(result_lines)
+    
+    return code
+
+if __name__ == '__main__':
+    if len(sys.argv) > 1:
+        with open(sys.argv[1], 'r') as f:
+            code = f.read()
+    else:
+        code = sys.stdin.read()
+    
+    minified = minify_cpp(code)
+    print(minified)
+    
+    # Print stats to stderr
+    original_size = len(code)
+    minified_size = len(minified)
+    print(f"Original: {original_size} bytes", file=sys.stderr)
+    print(f"Minified: {minified_size} bytes", file=sys.stderr)
+    print(f"Reduction: {original_size - minified_size} bytes ({100*(1-minified_size/original_size):.1f}%)", file=sys.stderr)