Upload hf_test_runner.py with huggingface_hub

hf_test_runner.py

@@ -0,0 +1,874 @@
+"""
+Test runner for the Idea First, Code Later CP Benchmark dataset.
+
+This module provides tools to load competitive programming problems from the
+Hugging Face dataset and run solutions against their test cases.
+
+Features:
+    - Automatic dataset loading from Hugging Face
+    - Support for C++ and Python solutions
+    - Special judge support for problems with multiple valid outputs
+    - Kattis integration for CS3233 problems
+    - Memory and time limit enforcement
+
+Example:
+    >>> from hf_test_runner import TestRunner
+    >>> runner = TestRunner()
+    >>> results = runner.run_solution(
+    ...     problem_id="icpc-jakarta-2019_card-collecting",
+    ...     solution_code=open("solution.cpp").read(),
+    ...     language="cpp"
+    ... )
+    >>> print(results["status"])  # "PASSED" or error type
+
+Classes:
+    TestRunner: Main class for running solutions against problems.
+    Problem: Dataclass representing a problem from the dataset.
+
+Functions:
+    run_solution: Convenience function for quick one-off solution testing.
+    parse_time_limit: Parse time limit strings like "2 sec" to float.
+    parse_memory_limit_to_bytes: Parse memory limit strings to bytes.
+"""
+
+import os
+import re
+import subprocess
+import tempfile
+import time
+import signal
+import resource
+import traceback
+from dataclasses import dataclass
+from typing import Optional
+
+try:
+    from datasets import load_dataset
+except ImportError:
+    print("Please install datasets: pip install datasets")
+    raise
+
+
+# Constants
+PREEXEC_ERROR_EXIT_CODE = 2
+HF_DATASET_ID = "samahadhoud/idea-first-code-later-cp"
+
+
+@dataclass
+class Problem:
+    """
+    Represents a competitive programming problem loaded from the HF dataset.
+    
+    Attributes:
+        problem_id: Unique identifier in format "contest_slug" (e.g., "icpc-jakarta-2019_card-collecting")
+        problem_code: Problem letter in the contest (A, B, C, ...)
+        problem_slug: URL-friendly problem name
+        problem_title: Full human-readable problem title
+        
+        contest_name: Contest identifier (e.g., "icpc-jakarta-2019")
+        contest_full_name: Full contest name (e.g., "ICPC Asia Jakarta Regional Contest 2019")
+        year: Competition year as string
+        source: Source URL or repository
+        
+        time_limit: Time limit as string (e.g., "2 sec")
+        memory_limit: Memory limit as string (e.g., "256 MB")
+        
+        statement: Problem statement in Markdown format
+        analysis: Editorial/solution analysis in Markdown
+        
+        sample_test_cases_input: List of sample input strings (shown in problem statement)
+        sample_test_cases_output: List of corresponding sample outputs
+        hidden_test_cases_input: List of hidden input strings (for actual judging)
+        hidden_test_cases_output: List of corresponding hidden outputs
+        
+        has_special_judge: True if problem accepts multiple valid outputs
+        special_judge_code: C++ scorer code using testlib for validation
+        special_judge_format: "standard" or "jakarta2017" (different CLI formats)
+        
+        uses_kattis: True for CS3233 problems (must submit via Kattis)
+        kattis_problem_id: Kattis problem ID for submission
+    """
+    problem_id: str
+    problem_code: str
+    problem_slug: str
+    problem_title: str
+    
+    contest_name: str
+    contest_full_name: str
+    year: str
+    source: str
+    
+    time_limit: str
+    memory_limit: str
+    
+    statement: str
+    analysis: str
+    
+    sample_test_cases_input: list
+    sample_test_cases_output: list
+    hidden_test_cases_input: list
+    hidden_test_cases_output: list
+    
+    has_special_judge: bool
+    special_judge_code: str
+    special_judge_format: str
+    
+    uses_kattis: bool
+    kattis_problem_id: str
+
+
+def parse_time_limit(time_str: str) -> float:
+    """
+    Parse a time limit string to seconds.
+    
+    Args:
+        time_str: Time limit string (e.g., "2 sec", "1.5s", "3")
+    
+    Returns:
+        Time limit in seconds as float. Returns 10.0 if parsing fails.
+    
+    Examples:
+        >>> parse_time_limit("2 sec")
+        2.0
+        >>> parse_time_limit("1.5s")
+        1.5
+        >>> parse_time_limit("")
+        10.0
+    """
+    if not time_str:
+        return 10.0  # default
+    match = re.search(r'([\d.]+)\s*(?:sec|s)?', time_str.lower())
+    if match:
+        return float(match.group(1))
+    return 10.0
+
+
+def parse_memory_limit_to_bytes(value) -> Optional[int]:
+    """
+    Parse a memory limit value to bytes.
+    
+    Args:
+        value: Memory limit as int (MB), float (MB), or string (e.g., "256 MB", "1 GB")
+    
+    Returns:
+        Memory limit in bytes, or None if unlimited/unspecified.
+    
+    Raises:
+        ValueError: If the value cannot be parsed or is negative.
+    
+    Examples:
+        >>> parse_memory_limit_to_bytes(256)
+        268435456
+        >>> parse_memory_limit_to_bytes("256 MB")
+        268435456
+        >>> parse_memory_limit_to_bytes("1 GB")
+        1073741824
+        >>> parse_memory_limit_to_bytes(None)
+        None
+    """
+    if value is None:
+        return None
+    if isinstance(value, (int, float)):
+        if value < 0:
+            raise ValueError("memory limit must be non-negative")
+        return int(value * 1024 * 1024)
+
+    if isinstance(value, str):
+        s = value.strip().lower()
+        if s in ("none", "unlimited", "0", ""):
+            return None
+        m = re.match(r"^\s*([0-9]*\.?[0-9]+)\s*([kmgtp]?b?|)$", s)
+        if not m:
+            raise ValueError(f"cannot parse memory limit '{value}'")
+        num = float(m.group(1))
+        unit = m.group(2)
+        if unit in ("", "b"):
+            multiplier = 1024 * 1024
+        elif unit in ("k", "kb"):
+            multiplier = 1024
+        elif unit in ("m", "mb"):
+            multiplier = 1024 * 1024
+        elif unit in ("g", "gb"):
+            multiplier = 1024 * 1024 * 1024
+        else:
+            raise ValueError(f"unknown unit in memory limit '{value}'")
+        return int(num * multiplier)
+
+    raise ValueError("unsupported type for memory limit")
+
+
+def _preexec_setrlimit_bytes(bytes_limit):
+    """
+    Set memory limit in child process using setrlimit.
+    
+    This function is designed to be used as a preexec_fn in subprocess.run().
+    It sets RLIMIT_AS (address space limit) to enforce memory limits on
+    the child process.
+    
+    Args:
+        bytes_limit: Memory limit in bytes, or None for no limit.
+    
+    Note:
+        If this function fails, it writes the traceback to stderr and
+        exits with PREEXEC_ERROR_EXIT_CODE (2) to signal the error.
+        On macOS, RLIMIT_AS may not be supported, so failures are silently ignored.
+    """
+    try:
+        if bytes_limit is None:
+            return
+        if not isinstance(bytes_limit, int) or bytes_limit < 0:
+            raise ValueError("bytes_limit must be non-negative int")
+        # Try to set memory limit (may fail on macOS)
+        try:
+            resource.setrlimit(resource.RLIMIT_AS, (bytes_limit, bytes_limit))
+        except (ValueError, OSError):
+            # RLIMIT_AS not supported on macOS, silently ignore
+            pass
+    except Exception:
+        try:
+            tb = traceback.format_exc()
+            os.write(2, tb.encode("utf-8", errors="replace"))
+        except Exception:
+            pass
+        os._exit(PREEXEC_ERROR_EXIT_CODE)
+
+
+class TestRunner:
+    """
+    Test runner for the Idea First, Code Later CP Benchmark dataset.
+    
+    This class loads problems from Hugging Face and provides methods to run
+    solutions against test cases with proper judging, time/memory limits,
+    and special judge support.
+    
+    Attributes:
+        dataset: The loaded HuggingFace dataset
+        problems: Dict mapping problem_id to problem data
+    
+    Example:
+        >>> runner = TestRunner()
+        >>> results = runner.run_solution(
+        ...     problem_id="icpc-jakarta-2019_card-collecting",
+        ...     solution_code=code,
+        ...     language="cpp"
+        ... )
+        >>> if results["status"] == "PASSED":
+        ...     print("All tests passed!")
+    """
+    
+    def __init__(self, dataset_id: str = HF_DATASET_ID, cache_dir: Optional[str] = None):
+        """
+        Initialize the test runner and load the dataset from Hugging Face.
+        
+        Args:
+            dataset_id: HuggingFace dataset ID (default: samahadhoud/idea-first-code-later-cp)
+            cache_dir: Optional local cache directory for the dataset
+        
+        Raises:
+            ImportError: If the datasets library is not installed
+        """
+        print(f"Loading dataset from {dataset_id}...")
+        self.dataset = load_dataset(dataset_id, cache_dir=cache_dir)["train"]
+        self.problems = {row["problem_id"]: row for row in self.dataset}
+        print(f"Loaded {len(self.problems)} problems")
+    
+    def get_problem(self, problem_id: str) -> Problem:
+        """
+        Retrieve a problem by its ID.
+        
+        Args:
+            problem_id: Unique problem identifier (e.g., "icpc-jakarta-2019_card-collecting")
+        
+        Returns:
+            Problem object with all problem data.
+        
+        Raises:
+            ValueError: If the problem_id is not found in the dataset.
+        
+        Example:
+            >>> problem = runner.get_problem("icpc-jakarta-2019_card-collecting")
+            >>> print(problem.problem_title)
+            'Card Collecting'
+        """
+        if problem_id not in self.problems:
+            raise ValueError(f"Problem {problem_id} not found. Available: {list(self.problems.keys())[:5]}...")
+        
+        row = self.problems[problem_id]
+        return Problem(
+            problem_id=row["problem_id"],
+            problem_code=row["problem_code"],
+            problem_slug=row["problem_slug"],
+            problem_title=row["problem_title"],
+            contest_name=row["contest_name"],
+            contest_full_name=row["contest_full_name"],
+            year=row["year"],
+            source=row["source"],
+            time_limit=row["time_limit"],
+            memory_limit=row["memory_limit"],
+            statement=row["statement"],
+            analysis=row["analysis"],
+            sample_test_cases_input=row["sample_test_cases_input"],
+            sample_test_cases_output=row["sample_test_cases_output"],
+            hidden_test_cases_input=row["hidden_test_cases_input"],
+            hidden_test_cases_output=row["hidden_test_cases_output"],
+            has_special_judge=row["has_special_judge"],
+            special_judge_code=row["special_judge_code"],
+            special_judge_format=row["special_judge_format"],
+            uses_kattis=row["uses_kattis"],
+            kattis_problem_id=row["kattis_problem_id"],
+        )
+    
+    def list_problems(self, contest: Optional[str] = None) -> list:
+        """
+        List all available problem IDs, optionally filtered by contest.
+        
+        Args:
+            contest: Optional substring to filter by (e.g., "jakarta-2019")
+        
+        Returns:
+            List of problem ID strings.
+        
+        Example:
+            >>> runner.list_problems()[:3]
+            ['cs3233-2023_a', 'cs3233-2023_b', 'cs3233-2023_c']
+            >>> runner.list_problems("jakarta-2017")
+            ['icpc-jakarta-2017_...']
+        """
+        if contest:
+            return [pid for pid in self.problems if contest in pid]
+        return list(self.problems.keys())
+    
+    def run_solution(
+        self,
+        problem_id: str,
+        solution_code: str,
+        language: str = "cpp",
+        run_hidden: bool = True,
+        solution_file: Optional[str] = None,
+    ) -> dict:
+        """
+        Run a solution against a problem's test cases.
+        
+        Executes the solution code against sample tests first, then hidden tests
+        if sample tests pass. Handles compilation, time/memory limits, and
+        special judges automatically.
+        
+        Args:
+            problem_id: The problem ID from the dataset
+            solution_code: The solution source code as a string
+            language: Programming language - "cpp" (default) or "Python"
+            run_hidden: Whether to run hidden test cases after samples pass
+            solution_file: Optional path to solution file (used for Kattis submission)
+        
+        Returns:
+            dict with keys:
+                - status: "PASSED", "Wrong Answer", "Time Limit Exceeded", 
+                          "Memory Limit Exceeded", "Runtime Error", or "Compile Error"
+                - problem_id: The problem ID
+                - problem_title: Human-readable problem title
+                - test_cases: List of individual test results
+                - sample_summary: Dict with pass/fail counts for sample tests
+                - hidden_summary: Dict with pass/fail counts for hidden tests
+        
+        Example:
+            >>> results = runner.run_solution(
+            ...     "icpc-jakarta-2019_card-collecting",
+            ...     open("solution.cpp").read(),
+            ...     language="cpp"
+            ... )
+            >>> print(results["status"])
+            'PASSED'
+        """
+        problem = self.get_problem(problem_id)
+        
+        # Handle Kattis problems
+        if problem.uses_kattis:
+            return self._run_kattis(problem, solution_code, solution_file, language)
+        
+        # Compile special judge if needed
+        scorer_executable = None
+        if problem.has_special_judge and problem.special_judge_code:
+            scorer_executable = self._compile_scorer(problem)
+        
+        results = {
+            "problem_id": problem_id,
+            "problem_title": problem.problem_title,
+            "status": "PASSED",
+            "test_cases": [],
+            "sample_summary": {},
+            "hidden_summary": {},
+        }
+        
+        time_limit = parse_time_limit(problem.time_limit)
+        memory_limit = problem.memory_limit
+        
+        # Run sample tests
+        sample_passed = self._run_tests(
+            problem, solution_code, language,
+            problem.sample_test_cases_input,
+            problem.sample_test_cases_output,
+            "sample", results, time_limit, memory_limit,
+            scorer_executable
+        )
+        
+        if not sample_passed:
+            return results
+        
+        # Run hidden tests
+        if run_hidden and problem.hidden_test_cases_input:
+            self._run_tests(
+                problem, solution_code, language,
+                problem.hidden_test_cases_input,
+                problem.hidden_test_cases_output,
+                "hidden", results, time_limit, memory_limit,
+                scorer_executable
+            )
+        
+        return results
+    
+    def _run_kattis(
+        self,
+        problem: Problem,
+        solution_code: str,
+        solution_file: Optional[str],
+        language: str
+    ) -> dict:
+        """
+        Submit a solution to Kattis for CS3233 problems.
+        
+        CS3233 problems are judged on Kattis and don't have local hidden test cases.
+        This method submits the solution via the Kattis CLI and parses the result.
+        
+        Args:
+            problem: The Problem object
+            solution_code: Solution source code
+            solution_file: Optional path to existing solution file
+            language: "cpp" or "Python"
+        
+        Returns:
+            dict with status, kattis_output, and execution time
+        
+        Note:
+            Requires kattis-cli to be installed and configured:
+            https://github.com/Kattis/kattis-cli
+        """
+        if not solution_file:
+            # Create temp file
+            ext = ".py" if language == "Python" else ".cpp"
+            with tempfile.NamedTemporaryFile(mode="w", suffix=ext, delete=False) as f:
+                f.write(solution_code)
+                solution_file = f.name
+        
+        print(f"Submitting to Kattis: {problem.kattis_problem_id}")
+        
+        try:
+            proc = subprocess.run(
+                ["kattis", solution_file, "-p", problem.kattis_problem_id, "-f"],
+                capture_output=True, text=True, timeout=300
+            )
+            
+            stdout = proc.stdout
+            stderr = proc.stderr
+            
+            print(f"📤 Kattis output:\n{stdout}")
+            
+            # Extract verdict
+            verdict_match = re.search(
+                r'(Accepted|Wrong Answer|Time Limit Exceeded|Run Time Error|Compile Error|Memory Limit Exceeded)',
+                stdout
+            )
+            time_match = re.search(r'\(([\d.]+)s\)', stdout)
+            
+            raw_verdict = verdict_match.group(1) if verdict_match else "Unknown"
+            
+            verdict_map = {
+                "Accepted": "PASSED",
+                "Wrong Answer": "Wrong Answer",
+                "Time Limit Exceeded": "Time Limit Exceeded",
+                "Run Time Error": "Runtime Error",
+                "Compile Error": "Compile Error",
+                "Memory Limit Exceeded": "Memory Limit Exceeded",
+                "Unknown": "Runtime Error"
+            }
+            
+            return {
+                "problem_id": problem.problem_id,
+                "problem_title": problem.problem_title,
+                "status": verdict_map.get(raw_verdict, "Runtime Error"),
+                "time": float(time_match.group(1)) if time_match else None,
+                "kattis_output": stdout,
+                "kattis_stderr": stderr,
+            }
+            
+        except Exception as e:
+            return {
+                "problem_id": problem.problem_id,
+                "status": "Submission Failed",
+                "error": str(e)
+            }
+    
+    def _compile_scorer(self, problem: Problem) -> Optional[str]:
+        """
+        Compile the special judge scorer for problems with multiple valid outputs.
+        
+        Some problems accept multiple correct answers (e.g., "print any valid permutation").
+        These use a custom scorer (written in C++ using testlib) to validate outputs.
+        
+        Args:
+            problem: The Problem object containing special_judge_code
+        
+        Returns:
+            Path to the compiled scorer executable, or None if compilation fails.
+        
+        Note:
+            The scorer is compiled with g++ -std=c++17. The executable is stored
+            in a temporary directory that persists for the duration of testing.
+            On macOS, bits/stdc++.h is replaced with standard includes.
+        """
+        # Create persistent temp directory for scorer (not auto-deleted)
+        tmp_dir = tempfile.mkdtemp(prefix="scorer_")
+        scorer_src = os.path.join(tmp_dir, "scorer.cpp")
+        scorer_exe = os.path.join(tmp_dir, "scorer")
+        
+        scorer_code = problem.special_judge_code
+        
+        # Handle bits/stdc++.h which doesn't exist on macOS
+        if "#include <bits/stdc++.h>" in scorer_code or '#include "bits/stdc++.h"' in scorer_code:
+            # Replace with common standard includes
+            replacement = """#include <iostream>
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <cmath>
+#include <set>
+#include <map>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <sstream>
+#include <fstream>"""
+            scorer_code = scorer_code.replace('#include <bits/stdc++.h>', replacement)
+            scorer_code = scorer_code.replace('#include "bits/stdc++.h"', replacement)
+        
+        with open(scorer_src, "w") as f:
+            f.write(scorer_code)
+        
+        result = subprocess.run(
+            ["g++", "-o", scorer_exe, scorer_src, "-std=c++17"],
+            capture_output=True, text=True
+        )
+        
+        if result.returncode != 0:
+            print(f"⚠️ Scorer compilation failed: {result.stderr}")
+            return None
+        
+        os.chmod(scorer_exe, 0o755)
+        return scorer_exe
+    
+    def _run_tests(
+        self,
+        problem: Problem,
+        solution_code: str,
+        language: str,
+        inputs: list,
+        outputs: list,
+        test_type: str,
+        results: dict,
+        time_limit: float,
+        memory_limit: str,
+        scorer_executable: Optional[str],
+    ) -> bool:
+        """
+        Run a set of test cases against a solution.
+        
+        Executes the solution for each input, compares output with expected,
+        and handles time/memory limits and special judging.
+        
+        Args:
+            problem: The Problem object
+            solution_code: Source code to execute
+            language: "cpp" or "Python"
+            inputs: List of input strings
+            outputs: List of expected output strings
+            test_type: "sample" or "hidden" (for labeling results)
+            results: Dict to append test results to (modified in place)
+            time_limit: Time limit in seconds
+            memory_limit: Memory limit as string (e.g., "256 MB")
+            scorer_executable: Path to compiled scorer, or None for exact match
+        
+        Returns:
+            True if all tests passed, False if any test failed.
+        
+        Note:
+            Stops on first failure and updates results["status"] accordingly.
+        """
+        tally = {"PASSED": 0, "TLE": 0, "MLE": 0, "Wrong Answer": 0, "RTE": 0, "CE": 0}
+        
+        # Parse memory limit
+        try:
+            bytes_limit = parse_memory_limit_to_bytes(memory_limit)
+        except ValueError:
+            bytes_limit = None
+        
+        # Compile C++ if needed
+        executable = None
+        if language == "cpp":
+            executable = self._compile_cpp(solution_code, problem.problem_slug)
+            if executable is None:
+                results["status"] = "Compile Error"
+                tally["CE"] += 1
+                results[f"{test_type}_summary"] = tally
+                return False
+        else:  # Python - check syntax once before running tests
+            try:
+                compile(solution_code, "<solution>", "exec")
+            except SyntaxError as se:
+                results["status"] = "Compile Error"
+                results["test_cases"].append({
+                    "test": f"{test_type}_1",
+                    "result": "Compile Error",
+                    "error": str(se)
+                })
+                tally["CE"] += 1
+                results[f"{test_type}_summary"] = tally
+                return False
+        
+        # Calculate timeout (time_limit + 5s buffer, capped at 60s)
+        timeout = min(60, time_limit + 5)
+        
+        for i, (input_data, expected_output) in enumerate(zip(inputs, outputs)):
+            test_name = f"{test_type}_{i+1}"
+            
+            try:
+                # Run the solution
+                start_time = time.time()
+                
+                if language == "cpp":
+                    proc = subprocess.run(
+                        [executable],
+                        input=input_data, text=True, capture_output=True,
+                        timeout=timeout,
+                        preexec_fn=lambda bl=bytes_limit: _preexec_setrlimit_bytes(bl)
+                    )
+                else:  # Python
+                    proc = subprocess.run(
+                        ["python3", "-c", solution_code],
+                        input=input_data, text=True, capture_output=True,
+                        timeout=timeout,
+                        preexec_fn=lambda bl=bytes_limit: _preexec_setrlimit_bytes(bl)
+                    )
+                
+                execution_time = time.time() - start_time
+                generated_output = (proc.stdout or "").strip()
+                
+                # Check for errors
+                if proc.returncode == PREEXEC_ERROR_EXIT_CODE:
+                    raise RuntimeError("preexec_fn failed")
+                
+                if proc.returncode is not None and proc.returncode < 0:
+                    sig = -proc.returncode
+                    if sig == signal.SIGKILL:
+                        raise MemoryError("Killed by SIGKILL (likely OOM)")
+                
+                if proc.returncode == 137:
+                    raise MemoryError("Exit code 137 (OOM)")
+                
+                if proc.returncode != 0:
+                    raise RuntimeError(f"Non-zero exit: {proc.returncode}, stderr: {proc.stderr}")
+                
+                # Judge output
+                is_correct = self._judge_output(
+                    problem, input_data, expected_output, generated_output,
+                    scorer_executable
+                )
+                
+                if is_correct:
+                    results["test_cases"].append({
+                        "test": test_name,
+                        "result": "PASSED",
+                        "time": execution_time,
+                    })
+                    tally["PASSED"] += 1
+                    print(f"✅ {test_name} Passed ({execution_time:.2f}s)")
+                else:
+                    results["status"] = "Wrong Answer"
+                    results["test_cases"].append({
+                        "test": test_name,
+                        "result": "Wrong Answer",
+                        "time": execution_time,
+                        "expected": expected_output[:200] + "..." if len(expected_output) > 200 else expected_output,
+                        "generated": generated_output[:200] + "..." if len(generated_output) > 200 else generated_output,
+                    })
+                    tally["Wrong Answer"] += 1
+                    print(f"❌ {test_name} Wrong Answer")
+                    results[f"{test_type}_summary"] = tally
+                    return False
+                    
+            except subprocess.TimeoutExpired:
+                results["status"] = "Time Limit Exceeded"
+                results["test_cases"].append({"test": test_name, "result": "TLE"})
+                tally["TLE"] += 1
+                print(f"⏳ {test_name} TLE")
+                results[f"{test_type}_summary"] = tally
+                return False
+                
+            except MemoryError as e:
+                results["status"] = "Memory Limit Exceeded"
+                results["test_cases"].append({"test": test_name, "result": "MLE", "error": str(e)})
+                tally["MLE"] += 1
+                print(f"💾 {test_name} MLE")
+                results[f"{test_type}_summary"] = tally
+                return False
+                
+            except Exception as e:
+                results["status"] = "Runtime Error"
+                results["test_cases"].append({"test": test_name, "result": "RTE", "error": str(e)})
+                tally["RTE"] += 1
+                print(f"❌ {test_name} Runtime Error: {e}")
+                results[f"{test_type}_summary"] = tally
+                return False
+        
+        results[f"{test_type}_summary"] = tally
+        return True
+    
+    def _compile_cpp(self, solution_code: str, name: str) -> Optional[str]:
+        """
+        Compile a C++ solution to an executable.
+        
+        Args:
+            solution_code: C++ source code as a string
+            name: Base name for the source file and executable
+        
+        Returns:
+            Path to the compiled executable, or None if compilation fails.
+        
+        Note:
+            Compiles with: g++ -o <exe> <src> -std=c++17 -O2
+            Compilation errors are printed to stdout.
+        """
+        tmp_dir = tempfile.mkdtemp()
+        cpp_file = os.path.join(tmp_dir, f"{name}.cpp")
+        executable = os.path.join(tmp_dir, f"{name}.out")
+        
+        with open(cpp_file, "w") as f:
+            f.write(solution_code)
+        
+        result = subprocess.run(
+            ["g++", "-o", executable, cpp_file, "-std=c++17", "-O2"],
+            capture_output=True, text=True
+        )
+        
+        if result.returncode != 0:
+            print(f"❌ Compile Error:\n{result.stderr}")
+            return None
+        
+        return executable
+    
+    def _judge_output(
+        self,
+        problem: Problem,
+        input_data: str,
+        expected_output: str,
+        generated_output: str,
+        scorer_executable: Optional[str],
+    ) -> bool:
+        """
+        Judge whether the generated output is correct.
+        
+        First attempts exact string match (after stripping whitespace).
+        If that fails and a special judge is available, uses the scorer.
+        
+        Args:
+            problem: The Problem object
+            input_data: The input that was given to the solution
+            expected_output: The expected output from test case
+            generated_output: The output produced by the solution
+            scorer_executable: Path to compiled scorer, or None
+        
+        Returns:
+            True if the output is correct, False otherwise.
+        
+        Note:
+            Special judge formats:
+            - "standard": scorer <input> <judge_output> <contestant_output>
+            - "jakarta2017": scorer <input> <unused> <judge_output> < contestant_output
+        """
+        expected_output = expected_output.strip()
+        generated_output = generated_output.strip()
+        
+        # Exact match
+        if generated_output == expected_output:
+            return True
+        
+        # Use special judge if available
+        if scorer_executable and problem.has_special_judge:
+            with tempfile.TemporaryDirectory() as tmp_dir:
+                input_file = os.path.join(tmp_dir, "input.txt")
+                expected_file = os.path.join(tmp_dir, "expected.txt")
+                generated_file = os.path.join(tmp_dir, "generated.txt")
+                
+                with open(input_file, "w") as f:
+                    f.write(input_data)
+                with open(expected_file, "w") as f:
+                    f.write(expected_output)
+                with open(generated_file, "w") as f:
+                    f.write(generated_output)
+                
+                if problem.special_judge_format == "jakarta2017":
+                    # Format: scorer <input> <unused> <judge_output> < contestant_output
+                    proc = subprocess.run(
+                        [scorer_executable, input_file, "dummy", expected_file],
+                        input=generated_output, text=True, capture_output=True
+                    )
+                    # Returns nothing for AC, "WA" for wrong
+                    return "WA" not in proc.stdout and proc.returncode == 0
+                else:
+                    # Standard format: scorer <input> <judge_output> <contestant_output>
+                    proc = subprocess.run(
+                        [scorer_executable, input_file, expected_file, generated_file],
+                        capture_output=True, text=True
+                    )
+                    # Check for AC in output or successful return code with no WA
+                    output = proc.stdout.strip().upper()
+                    return "AC" in output or (proc.returncode == 0 and "WA" not in output)
+        
+        return False
+
+
+# Convenience function
+def run_solution(problem_id: str, solution_code: str, language: str = "cpp") -> dict:
+    """
+    Convenience function to quickly run a solution against a problem.
+    
+    Creates a TestRunner instance, runs the solution, and returns results.
+    For running multiple solutions, create a TestRunner instance directly
+    to avoid reloading the dataset each time.
+    
+    Args:
+        problem_id: The problem ID from the dataset
+        solution_code: Solution source code as a string
+        language: "cpp" (default) or "Python"
+    
+    Returns:
+        dict with status and test results (see TestRunner.run_solution)
+    
+    Example:
+        >>> from hf_test_runner import run_solution
+        >>> results = run_solution("icpc-jakarta-2019_card-collecting", code)
+        >>> print(results["status"])
+    """
+    runner = TestRunner()
+    return runner.run_solution(problem_id, solution_code, language)
+
+
+if __name__ == "__main__":
+    # Example usage
+    runner = TestRunner()
+    
+    # List some problems
+    print("\nAvailable problems (first 10):")
+    for pid in runner.list_problems()[:10]:
+        p = runner.get_problem(pid)
+        print(f"  {pid}: {p.problem_title}")
+        print(f"    Sample tests: {len(p.sample_test_cases_input)}, Hidden: {len(p.hidden_test_cases_input)}")
+        print(f"    Special judge: {p.has_special_judge}, Kattis: {p.uses_kattis}")