Algorithm Design Examples

#include <bits/stdc++.h>
using namespace std;

int main(){
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

import os
import random
from pathlib import Path
from frontier_cs.single_evaluator import SingleEvaluator
from frontier_cs.runner.base import EvaluationStatus

# Support multiple judge servers for load balancing
DEFAULT_JUDGE_URL = "http://localhost:8081"
JUDGE_URLS = os.environ.get("JUDGE_URLS", DEFAULT_JUDGE_URL).split(",")

def get_judge_url():
    """Random selection for load balancing"""
    return random.choice(JUDGE_URLS)

def evaluate(program_path: str, problem_id: str = None):
    """
    Evaluate C++ solution for a Frontier-CS problem.
    
    Args:
        program_path: Path to C++ solution file
        problem_id: Problem ID (0-171) or from FRONTIER_CS_PROBLEM env var
    
    Returns:
        dict with combined_score and evaluation metadata
    """
    # Get problem ID from parameter or environment
    if problem_id is None:
        problem_id = os.environ.get('FRONTIER_CS_PROBLEM', '0')
    
    # Initialize judge
    evaluator = SingleEvaluator(
        backend="docker",
        judge_url=get_judge_url(),
        register_cleanup=False
    )
    
    # Read solution code
    solution_path = Path(program_path)
    if not solution_path.exists():
        return {
            "combined_score": 0.0,
            "status": "error",
            "message": f"File not found: {program_path}"
        }
    
    code = solution_path.read_text()
    
    # Submit to judge
    result = evaluator.evaluate(
        track="algorithmic",
        problem_id=problem_id,
        code=code,
        backend="docker"
    )
    
    # Process result
    if result.status == EvaluationStatus.SUCCESS:
        score = result.score
        # Use unbounded score (can exceed 100 if beating reference)
        score_unbounded = result.metadata.get(
            'scoreUnbounded', score
        ) if result.metadata else score
        
        return {
            "combined_score": float(score),
            "score_unbounded": score_unbounded,
            "status": "success",
            "problem_id": problem_id,
            "duration_seconds": result.duration_seconds
        }
    
    elif result.status == EvaluationStatus.TIMEOUT:
        return {
            "combined_score": 0.0,
            "status": "timeout",
            "message": result.message
        }
    
    else:  # ERROR
        return {
            "combined_score": 0.0,
            "status": "error",
            "message": result.message,
            "logs": result.logs
        }

#!/usr/bin/env python3
import argparse
import subprocess
from concurrent.futures import ProcessPoolExecutor
from pathlib import Path

def run_single_problem(problem_id, search_algo, iterations):
    """Run evolution for a single problem"""
    cmd = [
        "skydiscover-run",
        "initial_program.cpp",
        "evaluator.py",
        "-c", "config.yaml",
        "-s", search_algo,
        "-i", str(iterations)
    ]
    
    env = os.environ.copy()
    env["FRONTIER_CS_PROBLEM"] = str(problem_id)
    
    result = subprocess.run(cmd, env=env, capture_output=True)
    return problem_id, result.returncode

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--search", default="adaevolve")
    parser.add_argument("--iterations", type=int, default=50)
    parser.add_argument("--workers", type=int, default=6)
    args = parser.parse_args()
    
    # Run all 172 problems in parallel
    with ProcessPoolExecutor(max_workers=args.workers) as executor:
        futures = [
            executor.submit(
                run_single_problem, 
                problem_id, 
                args.search, 
                args.iterations
            )
            for problem_id in range(172)
        ]
        
        for future in futures:
            problem_id, status = future.result()
            print(f"Problem {problem_id}: {'✓' if status == 0 else '✗'}")

system_prompt: |
  You are solving a competitive programming problem.
  Write efficient C++ code that passes all test cases.
  
language: cpp
diff_based_generation: true

search_algorithm:
  population_size: 20
  tournament_size: 3