| |
| """ |
| Validator for problem 065: General Algorithm for Difference Bases |
| |
| Test an algorithm that produces difference bases at multiple values of n. |
| |
| Expected input format: |
| { |
| "algorithm": "description", |
| "test_cases": [ |
| {"n": n, "basis": [b0, b1, ...]}, |
| ... |
| ] |
| } |
| """ |
|
|
| import argparse |
| import math |
| from typing import Any |
|
|
| from . import ValidationResult, load_solution, output_result, success, failure |
|
|
|
|
| def baseline_ratio(n: int) -> float: |
| """Compute baseline efficiency: (2 * ceil(sqrt(n)))^2 / n.""" |
| return (2 * math.ceil(math.sqrt(n))) ** 2 / n |
|
|
|
|
| def verify_difference_basis(n: int, basis: list[int]) -> tuple[bool, int]: |
| """Verify a difference basis and return (valid, size).""" |
| B = set(basis) |
|
|
| |
| for b in B: |
| if b < 0 or b >= n: |
| return False, len(B) |
|
|
| |
| differences = set() |
| for a in B: |
| for b in B: |
| diff = abs(a - b) |
| if diff > 0: |
| differences.add(diff) |
|
|
| |
| missing = set(range(1, n)) - differences |
| return len(missing) == 0, len(B) |
|
|
|
|
| def validate(solution: Any) -> ValidationResult: |
| """ |
| Validate a general difference basis algorithm. |
| |
| Args: |
| solution: Dict with algorithm and test cases |
| |
| Returns: |
| ValidationResult with performance analysis |
| """ |
| try: |
| if not isinstance(solution, dict): |
| return failure("Invalid format: expected dict") |
|
|
| algorithm = solution.get('algorithm', 'not provided') |
| test_cases = solution.get('test_cases', []) |
|
|
| if not test_cases: |
| return failure("Need at least one test case") |
|
|
| except (ValueError, TypeError) as e: |
| return failure(f"Failed to parse solution: {e}") |
|
|
| results = [] |
| all_valid = True |
| beats_baseline_count = 0 |
|
|
| for tc in test_cases: |
| n = int(tc['n']) |
| basis = [int(b) for b in tc['basis']] |
|
|
| valid, size = verify_difference_basis(n, basis) |
| ratio = (size ** 2) / n |
| bl_ratio = baseline_ratio(n) |
| beats = valid and ratio < bl_ratio |
|
|
| if not valid: |
| all_valid = False |
| if beats: |
| beats_baseline_count += 1 |
|
|
| results.append({ |
| 'n': n, |
| 'basis_size': size, |
| 'ratio': ratio, |
| 'baseline_ratio': bl_ratio, |
| 'beats_baseline': beats, |
| 'valid': valid |
| }) |
|
|
| if not all_valid: |
| invalid = [r for r in results if not r['valid']] |
| return failure( |
| f"Invalid difference basis for n={invalid[0]['n']}", |
| test_results=results |
| ) |
|
|
| avg_ratio = sum(r['ratio'] for r in results) / len(results) |
| metrics = dict( |
| algorithm=algorithm, |
| test_results=results, |
| average_ratio=avg_ratio, |
| beats_baseline_count=beats_baseline_count, |
| num_test_cases=len(results), |
| ) |
|
|
| if beats_baseline_count == 0: |
| details = [f"n={r['n']}: ratio={r['ratio']:.4f} vs baseline={r['baseline_ratio']:.4f}" for r in results[:5]] |
| return failure( |
| f"Valid bases but none beat the baseline (need |B|²/n < (2*ceil(sqrt(n)))²/n). " |
| f"{'; '.join(details)}", |
| **metrics, |
| ) |
|
|
| return success( |
| f"Difference basis algorithm valid for all {len(results)} test cases " |
| f"(avg |B|²/n: {avg_ratio:.4f}). " |
| f"Beats baseline in {beats_baseline_count}/{len(results)} test cases.", |
| **metrics, |
| ) |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description='Validate general difference basis algorithm') |
| parser.add_argument('solution', help='Solution as JSON string or path to JSON file') |
| parser.add_argument('--verbose', '-v', action='store_true', help='Verbose output') |
| args = parser.parse_args() |
|
|
| solution = load_solution(args.solution) |
| result = validate(solution) |
| output_result(result) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
