Agent Skills: XCPC: jiangly C++ Style

XCPC: jiangly C++ Style

Overview

Proven C++ coding style from jiangly's Codeforces submissions. Focuses on safety, maintainability, and modern C++ features for competitive programming.

Core principle: Zero global pollution, zero global arrays, explicit types, modern C++.

When to Use

• Writing C++ solutions for Codeforces, ICPC, AtCoder, etc.
• Creating competitive programming templates
• Reviewing contest solutions
• Teaching competitive programming best practices

Don't use for:

• Production C++ code (different requirements)
• Non-competitive programming projects

MANDATORY WORKFLOW - READ BEFORE WRITING CODE

This skill enforces strict adherence to jiangly's coding style. You MUST follow this workflow:

Step 1: Consult Rules Before Writing

Before writing ANY code, you MUST:

1. Read the relevant rule files in rules/ directory based on your task
2. Check Red Flags table below to avoid common mistakes
3. Reference examples from rule files - they are the source of truth

Step 2: Match Rule Requirements

For each code decision, verify against rules:

| Task | Rule File | Key Points | |------|-----------|------------| | Variable naming | rules/naming.md | snake_case, uppercase for temp count arrays (S, T) | | String operations | rules/in-place-operations.md | reserve(), swap() for reuse | | Temporary arrays | rules/scope-control.md | Block scopes {}, timely release | | Logical operators | rules/formatting.md | Use and, or, not keywords | | Loop comparisons | rules/minimal-code.md | Symmetric patterns: s[i] <= t[j] | | Memory usage | rules/in-place-operations.md | vis arrays, no duplicate containers | | Function design | rules/struct-patterns.md | Constructors, const correctness |

Step 3: Verify Against Red Flags

Before finalizing code, check EVERY row in the Red Flags table below.

If any pattern matches, you MUST fix it before output.

Step 4: Self-Correction Checklist

After writing code, verify:

• [ ] No using namespace std;
• [ ] No global arrays (all in solve())
• [ ] Used using i64 = long long;
• [ ] Used and/or/not instead of &&/||/!
• [ ] Used std:: prefix everywhere
• [ ] 4-space indentation, K&R braces
• [ ] No line compression (one statement per line)
• [ ] Used "\n" not std::endl
• [ ] Large temporary arrays in block scopes {}
• [ ] Strings preallocated with reserve() when size known
• [ ] Used swap() for O(1) variable reuse
• [ ] Used push_back() for single characters, not +=
• [ ] Symmetric comparison patterns (a[i] <= b[j])
• [ ] Uppercase names for temporary count arrays (S, T)
• [ ] Use iota + lambda for index-value sorting, not structs
• [ ] Loop variables initialized in for header when possible
• [ ] Output uses " \n"[i == n - 1] for space-separated values

Rule Files are PRIMARY Reference

The Quick Reference table below is a summary. Rule files contain the complete, authoritative examples. When in doubt, read the rule file.

| Category | Rule | File | |----------|------|------| | Namespace | Never using namespace std; | no-global-namespace | | Arrays | Zero global arrays | zero-global-arrays | | Types | Use using i64 = long long; | explicit-types | | Indexing | Follow problem's natural indexing | keep-indexing-consistent | | I/O | Disable sync, use \n | fast-io | | Naming | snake_case for vars, PascalCase for structs | naming | | Minimal | Avoid unnecessary variables, merge conditions | minimal-code | | Formatting | 4-space indent, K&R braces, no line compression | formatting | | Simplicity | Prefer simple data structures | simplicity-first | | Memory | Use in-place operations | in-place-operations | | Scope | Use block scopes for temporaries | scope-control | | DFS | Use depth array, avoid parent parameter | dfs-techniques | | Recursion | Lambda + self pattern | recursion | | Structs | Constructor patterns, const correctness | struct-patterns | | Operators | Overload patterns for custom types | operator-overloading | | Helpers | chmax, ceilDiv, gcd, power, etc. | helper-functions | | DP | Use vector, never memset | dp-patterns | | Modern C++ | CTAD, structured binding, C++20 features | modern-cpp-features |

Code Template

#include <bits/stdc++.h>

using i64 = long long;

void solve() {
    int n;
    std::cin >> n;

    std::vector<int> a(n);
    for (int i = 0; i < n; i++) {
        std::cin >> a[i];
    }

    std::cout << ans << "\n";
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int t;
    std::cin >> t;

    while (t--) {
        solve();
    }

    return 0;
}

Red Flags - STOP

| Anti-pattern | Correct approach | |--------------|------------------| | using namespace std; | Use std:: prefix | | int a[100005]; global | std::vector<int> a(n); in solve() | | #define int long long | using i64 = long long; | | for (int i = 1; i <= n; i++) | for (int i = 0; i < n; i++) OR keep problem's indexing | | void dfs(int u, int p) global | Lambda with self capture | | std::endl | Use "\n" | | if (x) do_something(); | Always use braces | | a && b logical operators | Use and, or, not keywords | | Over-engineered HLD + segment tree | Use binary lifting for simple path queries | | Creating e1, e2 containers | Use vis boolean array | | Converting 1-indexed to 0-indexed | Keep original indexing | | Expanding boolean logic into verbose if-else | Merge conditions | | Introducing unnecessary intermediate variables | Use direct formulas | | Over-semantic local variable names | Use x, y, l, r for short-lived vars | | Passing parent in DFS | Use depth array to check visited | | Explicit template parameters | Use CTAD where possible | | Large arrays at function scope | Use block scopes {} for temporaries | | String without reserve() | Preallocate for known size | | Variable assignment instead of swap() | Use O(1) swap | | Creating struct for simple index-value sort | Use std::iota + lambda | | Loop variable initialized outside for | Initialize in for header: for (int i = 0, j = 0; ...) | | Output with trailing space handling | Use " \n"[i == n - 1] trick |

Full Documentation

For complete details on all rules: AGENTS.md

FINAL CHECKPOINT - BEFORE OUTPUTTING CODE

You MUST verify ALL items below before showing code to user:

□ Read relevant rule files (naming.md, formatting.md, etc.)
□ Checked against Red Flags table
□ No `using namespace std;`
□ No global arrays
□ Used `i64` for long long
□ Used `and`/`or`/`not` keywords
□ Used `std::` prefix throughout
□ 4-space indent, K&R braces
□ No compressed lines
□ Used `"\n"` not `std::endl`
□ Temporary arrays in block scopes
□ String operations use `reserve()` and `swap()`
□ Symmetric comparison patterns
□ Uppercase temp array names (S, T)
□ Use iota + lambda for sorting with indices
□ Loop vars in for header when scope permits
□ Output uses " \n"[i == n - 1] trick

If ANY item fails, fix before output. This is non-negotiable.