solutions-tutorial

Generate ICPC solutions with cross-check implementations and matching tutorials.

42|1|Updated Apr 28, 2026
One-click install
npx skills add https://github.com/Lumine2024/ICPC-Problem-Creator.skill --skill solutions-tutorial
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: solutions-tutorial
Source: https://github.com/Lumine2024/ICPC-Problem-Creator.skill/tree/main/subskills/solutions-tutorial
Command: npx skills add https://github.com/Lumine2024/ICPC-Problem-Creator.skill --skill solutions-tutorial

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It turns an ICPC solution task into a consistent, verifiable workflow by producing a correct main solution implementation plus an independently correct cross-check solution and a tutorial that matches the code and the target difficulty.

Core Features & Use Cases

  • Produces cross-validated solutions: writes src/solution.cpp and an independently correct src/solution2.cpp suitable for catching mistakes.
  • Generates runnable reference code when appropriate: writes src/solution.py only when it can be correct, runnable, and readable (not pseudocode).
  • Creates difficulty-aware tutorial content: drafts docs/tutorial.md with the right level of detail for the problem’s complexity while keeping correctness, edge cases, and complexity aligned with the implementations.

Quick Start

Ask your agent to generate the ICPC solutions by writing src/solution.cpp, src/solution2.cpp, and docs/tutorial.md consistent with the already confirmed problem core, target complexity, difficulty, and workspace path.

Frequently Asked Questions about solutions-tutorial

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I write ICPC solutions with cross-validation to catch implementation mistakes?

ICPC cross-validation generates a primary solution.cpp and an independently correct solution2.cpp to catch mistakes. It also produces a runnable solution.py when appropriate, ensuring both C++ implementations are independently correct.

How does difficulty-controlled tutorial writing work for competitive programming?

Difficulty-controlled tutorial writing drafts docs/tutorial.md with the right level of detail for the problem's complexity. It ensures all claims about edge cases and complexity exactly match the generated C++ and Python implementations.

Can I generate an editorial-style explanation that matches my ICPC solution code?

Yes, you can generate an editorial-style explanation that exactly matches your ICPC solution code. The tutorial aligns complexity and boundary claims with the primary solution and cross-check implementation for both normal and difficulty-controlled outputs.

What's the best way to ensure my ICPC solution tutorial matches the code?

The best way to ensure your ICPC solution tutorial matches the code is to generate them together. This cross-validates the solution implementations and enforces that tutorial claims on boundaries and complexity exactly match the code.

Do I need to provide a workspace path and target complexity to generate ICPC solutions?

Yes, you need to provide a workspace path and target complexity. The generation uses the already confirmed problem core, target complexity, difficulty, and workspace path to write src/solution.cpp, src/solution2.cpp, and docs/tutorial.md.

When should I not use an independently generated Python solution for competitive programming?

You should not use a generated Python solution when it cannot be correct, runnable, and readable. The process strictly writes src/solution.py only when it can provide actual runnable code rather than pseudocode.