wrong-gen

Generate wrong solutions and datasets for ICPC problem verification.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps ICPC problem production reliably create multiple wrong solutions and the corresponding generators/data so that near-TL or subtly incorrect approaches are caught during local verification.

Core Features & Use Cases

  • Mistake-driven wrong-solution enumeration: Systematically covers “idea mistakes,” “complexity mistakes,” and “implementation mistakes” using the provided mistake taxonomy.
  • Multi-family wrong solution implementation: Produces several compilable src/wrong/*.cpp programs plus a src/generator/generator.cpp that can generate targeted cases.
  • Config-aligned data generation: Updates config.json fields tied to generator.cases and wrongSolutions so generated datasets effectively distinguish the intended wrong families.
  • Targeted and stressful test design: Mixes directed datasets (to defeat specific wrong families) with random data as supplements, ensuring enough scale and strength to hit performance and edge traps.
  • Interactive-aware wrong strategies (if applicable): Extends enumeration to query strategy, order, and answering/fallback behaviors for interactive problems.

Quick Start

Ask the agent to produce wrong solution families and a generator for your current ICPC workspace, then update the config so the generated datasets can reproduce and defeat the planned wrong approaches.

Frequently Asked Questions about wrong-gen

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

FAQPage Schema
How do I generate wrong solutions for ICPC competitive programming problem verification?

To generate wrong solutions for ICPC competitive programming problem verification, this Skill systematically enumerates mistake taxonomy categories and produces multiple compilable wrong programs alongside targeted test data generators to expose incorrect algorithms during local judging.

What types of mistakes should wrong solution generators cover for competitive programming?

Wrong solution generators for competitive programming should cover idea mistakes, complexity mistakes, and implementation mistakes. This taxonomy ensures that near-TL approaches and subtly incorrect algorithms are reliably caught by the generated test datasets.

How do I set up a generator.cpp for local verification of wrong solutions?

To set up a generator for local verification, implement a compilable generator.cpp that accepts arguments for case type and seed. You then update config.json fields for generator.cases and wrongSolutions to ensure datasets effectively distinguish the planned wrong solution families.

Can I generate wrong solutions for interactive problems in ICPC problem preparation?

Yes, you can generate wrong solutions for interactive problems in ICPC problem preparation. The generation process extends mistake enumeration to cover interactive query strategies, query order, and answering or fallback behaviors to catch incorrect interactive approaches.

Do I need a fixed core solution before generating wrong solutions and test cases?

Yes, you need a fixed core solution before generating wrong solutions and test cases. The workflow requires the main agent to have already established the core solution, expected behavior, and a rough case plan for both standard and interactive problems before generating wrong approaches.

What is the best way to design test data that catches near-TL competitive programming solutions?

The best way to design test data that catches near-TL competitive programming solutions is to mix directed datasets, specifically designed to defeat known wrong solution families, with supplementary random data. This ensures enough scale and strength to hit performance limits and edge case traps.