AICodeforcer

Gemini-powered algorithm problem solver agent.

使用 Gemini AI 自动解决 Codeforces 等 OJ 平台的算法竞赛题目，支持自动对拍验证和 Python 转 C++ 翻译。

系统架构概览

┌─────────────────────────────────────────────────────────────────────────────┐
│                              AICodeforcer                                    │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                              │
│  ┌─────────────┐  ┌─────────────┐  ┌───────────────┐  ┌─────────────┐      │
│  │   Standard  │  │ Interactive │  │ Communication │  │    Heavy    │      │
│  │    Mode     │  │    Mode     │  │     Mode      │  │    Mode     │      │
│  └──────┬──────┘  └──────┬──────┘  └───────┬───────┘  └──────┬──────┘      │
│         │                  │                    │                            │
│         ▼                  ▼                    ▼                            │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────────┐                  │
│  │   Solver    │    │ Preprocessor│    │  Preprocessor   │                  │
│  │   Agent     │    │   Agent     │    │     Agent       │                  │
│  └──────┬──────┘    └──────┬──────┘    └────────┬────────┘                  │
│         │                  │                    │                            │
│         │                  ▼                    ▼                            │
│         │           ┌─────────────┐    ┌─────────────────┐                  │
│         │           │   Solver    │    │     Solver      │                  │
│         │           │   Agent     │    │     Agent       │                  │
│         │           └──────┬──────┘    └────────┬────────┘                  │
│         │                  │                    │                            │
│         ▼                  ▼                    ▼                            │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────────┐                  │
│  │ BruteForce  │    │   Stress    │    │     Stress      │                  │
│  │  Generator  │    │    Test     │    │      Test       │                  │
│  │ (3-way)     │    │             │    │                 │                  │
│  └──────┬──────┘    └──────┬──────┘    └────────┬────────┘                  │
│         │                  │                    │                            │
│         ▼                  ▼                    ▼                            │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────────┐                  │
│  │   Stress    │    │     C++     │    │       C++       │                  │
│  │    Test     │    │  Translator │    │   Translator    │                  │
│  └──────┬──────┘    └─────────────┘    └─────────────────┘                  │
│         │                                                                    │
│         ▼                                                                    │
│  ┌─────────────┐                                                            │
│  │     C++     │                                                            │
│  │  Translator │                                                            │
│  └─────────────┘                                                            │
│                                                                              │
├─────────────────────────────────────────────────────────────────────────────┤
│                           Shared Components                                  │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐        │
│  │  Executor   │  │  API Logger │  │   Types     │  │    Tools    │        │
│  │  (Sandbox)  │  │             │  │             │  │             │        │
│  └─────────────┘  └─────────────┘  └─────────────┘  └─────────────┘        │
└─────────────────────────────────────────────────────────────────────────────┘

功能特性

标准算法题模式
- 自动分析算法题目并生成解法
- 三路共识暴力生成（3 个独立 Agent 必须一致）
- 自动对拍验证（默认 1000 组随机测试）
- 失败自动重试机制
交互题模式
- 自动生成评测机（Judge）和数据生成器
- AI 验证评测机正确性
- 交互式对拍验证（默认 100 组测试）
通讯题模式
- 支持 Alice/Bob 两阶段通讯问题
- 自动生成中间件（Middleware）和验证器
- 两阶段串行执行对拍验证（默认 100 组测试）
Heavy模式（多Agent探索）
- 多个Agent并行探索不同解法
- 流水线并行：Agent N 首次 stress_test 时触发 Agent N+1
- LLM思路去重检测，防止重复算法
- 自动禁止已探索的思路，强制差异化
- 支持配置重写上限（APPROACH_REWRITE_LIMIT）
通用功能
- 使用沙箱环境执行代码测试
- Python 代码自动翻译为竞赛风格 C++
- 支持交互式反馈优化（TLE/WA/MLE/RE）
- 完整 API 请求/响应日志记录

安装

# 克隆项目
git clone https://github.com/yourname/AICodeforcer.git
cd AICodeforcer

# 使用 uv 安装依赖
uv sync

# 或使用 pip
pip install -e .

配置

创建 .env 文件并配置：

# Gemini API 配置（必需）
GEMINI_API_KEY=your_api_key_here

# 可选配置
GEMINI_MODEL=gemini-2.5-flash          # 模型名称
GEMINI_BASE_URL=https://your-proxy.com # 自定义 API 地址
GEMINI_MAX_OUTPUT_TOKENS=65536         # 最大输出 token 数

# API 请求重试次数
API_REQUEST_MAX_RETRIES=30             # API 请求失败重试次数

# 对拍测试次数
STRESS_TEST_NUM=1000                   # 标准模式对拍次数
INTERACTIVE_STRESS_TEST_NUM=100        # 交互模式对拍次数
COMMUNICATION_STRESS_TEST_NUM=100      # 通讯题模式对拍次数

# 重试配置
BRUTE_FORCE_CONSENSUS_RETRIES=3        # 三路共识失败重试次数

# Heavy模式配置
APPROACH_REWRITE_LIMIT=2               # 思路重写上限（去重检测）

配置项说明

配置项	默认值	说明
`GEMINI_API_KEY`	-	必需 Gemini API 密钥
`GEMINI_MODEL`	`gemini-2.5-flash`	使用的模型名称
`GEMINI_BASE_URL`	-	自定义 API 地址（代理）
`GEMINI_MAX_OUTPUT_TOKENS`	`65536`	单次请求最大输出 token
`API_REQUEST_MAX_RETRIES`	`30`	API 请求失败重试次数
`STRESS_TEST_NUM`	`1000`	标准模式对拍测试次数
`INTERACTIVE_STRESS_TEST_NUM`	`100`	交互模式对拍测试次数
`COMMUNICATION_STRESS_TEST_NUM`	`100`	通讯题模式对拍测试次数
`BRUTE_FORCE_CONSENSUS_RETRIES`	`3`	三路共识失败重试次数
`APPROACH_REWRITE_LIMIT`	`2`	Heavy模式思路重写上限

使用方法

# 运行
aicodeforcer

# 或
python -m AICodeforcer.main

运行后选择模式：

标准算法题 - 对拍验证模式
交互题 - 交互式评测模式
通讯题 - Alice/Bob 两阶段模式
Heavy模式 - 多Agent探索不同解法

然后：

粘贴完整的题目内容
输入 END 结束输入
等待 AI 分析、编写代码、对拍验证
获得 Python + C++ 双份代码
提交后输入反馈（如 TLE on test 5）继续优化
输入 AC 或 quit 结束

项目结构

src/AICodeforcer/
├── main.py                # CLI 入口
├── types.py               # 类型定义
├── api_logger.py          # API 日志记录器
├── standard/              # 标准算法题模块
│   ├── agents/
│   │   ├── solver.py      # 算法求解 Agent
│   │   ├── brute_force.py # 三路共识暴力生成
│   │   └── cpp_translator.py
│   └── tools/
│       ├── executor.py    # 沙箱代码执行器
│       ├── run_python.py  # 代码执行工具
│       └── stress_test.py # 对拍验证工具
├── standard_heavy/        # Heavy模式模块
│   └── agents/
│       ├── solver.py      # Heavy求解Agent
│       ├── heavy_solver.py # 多Agent协调器
│       └── approach_checker.py # 思路去重检测
└── interactive/           # 交互题模块
    ├── agents/
    │   ├── solver.py      # 交互题求解 Agent
    │   ├── preprocessor.py # 评测机生成器
    │   └── judge_validator.py
    └── tools/
        ├── interaction_runner.py    # IPC 通信管理
        └── interactive_stress_test.py
└── communication/         # 通讯题模块
    ├── agents/
    │   ├── solver.py      # 通讯题求解 Agent
    │   └── preprocessor.py # 中间件/验证器生成
    └── tools/
        ├── communication_runner.py  # 两阶段执行器
        └── stress_test.py           # 通讯题对拍

日志

每次运行会在 logs/ 下创建时间戳文件夹：

logs/20251224_165001/
├── solve.log              # 普通日志
├── solve_full.log         # 完整 API 日志
├── brute_force_full.log   # 暴力生成日志
└── brute_force_agent*_full.log

工作流程

1. 标准算法题模式 (Standard Mode)

┌──────────────────────────────────────────────────────────────────────────┐
│                        Standard Algorithm Solver                          │
└──────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌──────────────────────────────────────────────────────────────────────────┐
│  1. Problem Analysis (题意分析)                                           │
│     ├─ Restate problem in own words                                      │
│     ├─ Identify input/output format                                      │
│     └─ Build mathematical model                                          │
└──────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌──────────────────────────────────────────────────────────────────────────┐
│  2. Algorithm Design (算法设计)                                           │
│     ├─ Propose 2-3 candidate approaches                                  │
│     ├─ Analyze time/space complexity                                     │
│     └─ Select optimal approach with proof                                │
└──────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌──────────────────────────────────────────────────────────────────────────┐
│  3. Code Implementation (代码实现)                                        │
│     ├─ Write Python solution                                             │
│     ├─ Use run_python_code tool to test                                  │
│     └─ Verify with sample cases                                          │
└──────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌──────────────────────────────────────────────────────────────────────────┐
│  4. Brute Force Generation (暴力生成) - 3-Way Consensus                   │
│     ┌─────────────────────────────────────────────────────────────────┐  │
│     │  ┌─────────┐    ┌─────────┐    ┌─────────┐                      │  │
│     │  │ Agent 1 │    │ Agent 2 │    │ Agent 3 │  (Parallel)          │  │
│     │  └────┬────┘    └────┬────┘    └────┬────┘                      │  │
│     │       │              │              │                            │  │
│     │       ▼              ▼              ▼                            │  │
│     │  ┌─────────┐    ┌─────────┐    ┌─────────┐                      │  │
│     │  │ Code 1  │    │ Code 2  │    │ Code 3  │                      │  │
│     │  └────┬────┘    └────┬────┘    └────┬────┘                      │  │
│     │       └──────────────┼──────────────┘                            │  │
│     │                      ▼                                           │  │
│     │              ┌──────────────┐                                    │  │
│     │              │  Consensus?  │                                    │  │
│     │              │ (All Same?)  │                                    │  │
│     │              └──────┬───────┘                                    │  │
│     │                     │                                            │  │
│     │         ┌───────────┴───────────┐                                │  │
│     │         ▼                       ▼                                │  │
│     │    [Yes: Pass]           [No: Retry]                             │  │
│     └─────────────────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌──────────────────────────────────────────────────────────────────────────┐
│  5. Stress Test (对拍验证) - Default 1000 tests                          │
│     ┌─────────────────────────────────────────────────────────────────┐  │
│     │  for i in range(1000):                                          │  │
│     │      test_data = brute_force.generate_random_input()            │  │
│     │      expected = brute_force.solve(test_data)                    │  │
│     │      actual = optimized.solve(test_data)                        │  │
│     │      if expected != actual:                                     │  │
│     │          return FAILED with counterexample                      │  │
│     │  return PASSED                                                  │  │
│     └─────────────────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────────────────────┘
                                    │
                          ┌─────────┴─────────┐
                          ▼                   ▼
                    [PASSED]             [FAILED]
                          │                   │
                          ▼                   ▼
┌─────────────────────────────┐    ┌─────────────────────────┐
│  6. C++ Translation         │    │  Analyze counterexample │
│     Python → C++            │    │  Fix and retry          │
└─────────────────────────────┘    └─────────────────────────┘
                          │
                          ▼
┌──────────────────────────────────────────────────────────────────────────┐
│  7. Feedback Loop (反馈优化)                                              │
│     User submits to OJ → Gets feedback (TLE/WA/MLE/RE)                   │
│     → AI analyzes and optimizes → Repeat until AC                        │
└──────────────────────────────────────────────────────────────────────────┘

2. 交互题模式 (Interactive Mode)

┌──────────────────────────────────────────────────────────────────────────┐
│                        Interactive Problem Solver                         │
└──────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌──────────────────────────────────────────────────────────────────────────┐
│  Phase 1: Preprocessing (预处理阶段)                                      │
│  ┌────────────────────────────────────────────────────────────────────┐  │
│  │  InteractivePreprocessor Agent                                     │  │
│  │     ├─ Analyze interaction protocol                                │  │
│  │     ├─ Generate Judge (评测机)                                      │  │
│  │     │    └─ Reads test data from file                              │  │
│  │     │    └─ Interacts via stdin/stdout                             │  │
│  │     │    └─ Returns: 0=AC, 1=WA, 2=PE                              │  │
│  │     └─ Generate Data Generator (数据生成器)                         │  │
│  └────────────────────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌──────────────────────────────────────────────────────────────────────────┐
│  Phase 2: Judge Validation (评测机验证)                                   │
│     JudgeValidator Agent verifies judge correctness                      │
└──────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌──────────────────────────────────────────────────────────────────────────┐
│  Phase 3: Solution Development (解法开发)                                 │
│  ┌────────────────────────────────────────────────────────────────────┐  │
│  │  InteractiveSolver Agent                                           │  │
│  │     ├─ Analyze query strategy (Binary Search / Divide & Conquer)   │  │
│  │     ├─ Estimate query count upper bound                            │  │
│  │     ├─ Write interactive solution with flush=True                  │  │
│  │     └─ Handle -1 error responses                                   │  │
│  └────────────────────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌──────────────────────────────────────────────────────────────────────────┐
│  Phase 4: Interactive Stress Test (交互对拍) - Default 100 tests         │
│  ┌────────────────────────────────────────────────────────────────────┐  │
│  │  for i in range(100):                                              │  │
│  │      test_data = generator.generate()                              │  │
│  │      ┌─────────────┐         ┌─────────────┐                       │  │
│  │      │   Judge     │ ◄─────► │   Solver    │  (IPC Communication)  │  │
│  │      │  (stdin)    │         │  (stdout)   │                       │  │
│  │      └─────────────┘         └─────────────┘                       │  │
│  │      if judge.exit_code != 0: return FAILED                        │  │
│  │  return PASSED                                                     │  │
│  └────────────────────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌──────────────────────────────────────────────────────────────────────────┐
│  Phase 5: C++ Translation + Feedback Loop                                │
└──────────────────────────────────────────────────────────────────────────┘

3. 通讯题模式 (Communication Mode)

┌──────────────────────────────────────────────────────────────────────────┐
│                      Communication Problem Solver                         │
│                        (Alice & Bob Protocol)                             │
└──────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌──────────────────────────────────────────────────────────────────────────┐
│  Phase 1: Preprocessing (预处理阶段)                                      │
│  ┌────────────────────────────────────────────────────────────────────┐  │
│  │  CommunicationPreprocessor Agent generates:                        │  │
│  │     ├─ Data Generator (数据生成器)                                  │  │
│  │     ├─ Middleware (中间件) - transforms Alice output → Bob input   │  │
│  │     └─ Verifier (验证器) - checks final answer correctness         │  │
│  └────────────────────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌──────────────────────────────────────────────────────────────────────────┐
│  Phase 2: Solution Development (解法开发)                                 │
│  ┌────────────────────────────────────────────────────────────────────┐  │
│  │  CommunicationSolver Agent writes single file handling both phases │  │
│  │                                                                    │  │
│  │  def main():                                                       │  │
│  │      phase = input()  # "first" or "second"                        │  │
│  │      if phase == "first":                                          │  │
│  │          solve_alice()  # Process original input                   │  │
│  │      else:                                                         │  │
│  │          solve_bob()    # Process transformed input                │  │
│  └────────────────────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌──────────────────────────────────────────────────────────────────────────┐
│  Phase 3: Two-Phase Execution (两阶段执行)                                │
│  ┌────────────────────────────────────────────────────────────────────┐  │
│  │                                                                    │  │
│  │  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐            │  │
│  │  │  Original   │───►│   Solver    │───►│   Alice     │            │  │
│  │  │   Input     │    │  (Alice)    │    │   Output    │            │  │
│  │  └─────────────┘    └─────────────┘    └──────┬──────┘            │  │
│  │                                               │                    │  │
│  │                                               ▼                    │  │
│  │                                        ┌─────────────┐            │  │
│  │                                        │ Middleware  │            │  │
│  │                                        │ (Transform) │            │  │
│  │                                        └──────┬──────┘            │  │
│  │                                               │                    │  │
│  │                                               ▼                    │  │
│  │  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐            │  │
│  │  │   Final     │◄───│   Solver    │◄───│    Bob      │            │  │
│  │  │   Answer    │    │   (Bob)     │    │   Input     │            │  │
│  │  └─────────────┘    └─────────────┘    └─────────────┘            │  │
│  │                                                                    │  │
│  └────────────────────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌──────────────────────────────────────────────────────────────────────────┐
│  Phase 4: Communication Stress Test (通讯对拍) - Default 100 tests       │
│     Verifier checks: Final Answer == Expected Answer                     │
└──────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌──────────────────────────────────────────────────────────────────────────┐
│  Phase 5: C++ Translation + Feedback Loop                                │
└──────────────────────────────────────────────────────────────────────────┘

依赖

Python >= 3.10
google-genai >= 1.0.0
pydantic >= 2.0
python-dotenv >= 1.2.1

Ethical Declaration | 诚信宣言 | 君子之約

English

The sword forged for the training hall shall not be drawn where honor hangs in the balance.

This project exists as a crucible for learning — to witness the elegant dance of algorithms, to comprehend the silent poetry woven into logic. It is a mirror, not a mask; a teacher, not a surrogate.

To wield it in competition is to claim a crown of smoke, for victory without struggle is but the shadow of triumph. The laurels earned through borrowed wisdom shall wither before they are worn.

Let your mind be the true solver. Let this tool be merely the whetstone upon which you sharpen your own blade.

中文

习武之剑，不可执于论道之堂；练兵之器，不可持于争锋之场。

此项目为学习而生——让你得以窥见算法的曼妙之舞，领悟逻辑深处的无声诗篇。它是一面镜子，而非一张面具；是一位导师，而非替身。

若以此器竞于赛场，所摘不过是烟云编织的桂冠。不经磨砺的胜利，不过是荣耀的倒影。借来的智慧所铸的勋章，未及佩戴便已黯然失色。

愿君以心为剑，以此为砺石，磨砺属于自己的锋芒。

文言

器者，習藝之資也，非爭勝之具也。

此器之造，為明算理、窮邏輯之奧也。若持以赴試，竊人之功為己有，是欺世盜名之行，君子所不齒也。

古人云：「學如逆水行舟，不進則退。」又云：「君子務本，本立而道生。」

夫以械代心，猶飲鴆止渴，雖解一時之困，終貽無窮之患。所得者，虛名也；所失者，真學也。名可欺人，學不可欺己。

願諸君以誠為本，以學為先。器可助學，不可代學；技可借鑒，不可竊取。慎之戒之。

License

MIT

Name		Name	Last commit message	Last commit date
Latest commit History 13 Commits
src/AICodeforcer		src/AICodeforcer
.gitignore		.gitignore
LICENSE		LICENSE
README.md		README.md
pyproject.toml		pyproject.toml
uv.lock		uv.lock

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Repository files navigation

AICodeforcer

系统架构概览

功能特性

安装

配置

配置项说明

使用方法

项目结构

日志

工作流程

1. 标准算法题模式 (Standard Mode)

2. 交互题模式 (Interactive Mode)

3. 通讯题模式 (Communication Mode)

依赖

Ethical Declaration | 诚信宣言 | 君子之約

English

中文

文言

License

About

Uh oh!

Releases

Packages

Uh oh!

Contributors

Uh oh!

Languages

Folders and files

Latest commit

History

Repository files navigation

AICodeforcer

系统架构概览

功能特性

安装

配置

配置项说明

使用方法

项目结构

日志

工作流程

1. 标准算法题模式 (Standard Mode)

2. 交互题模式 (Interactive Mode)

3. 通讯题模式 (Communication Mode)

依赖

Ethical Declaration | 诚信宣言 | 君子之約

English

中文

文言

License

About

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Packages