DSA Pattern Practice

When to Use

• Interview / learning: classify a pattern · capture a STIC card · generate a starter Java template.
• Day-to-day code: audit complexity · choose a collection · refactor a nested loop · PR-review for Big-O.

Language-agnostic; Java is the shipped default. Path resolution: references/path-config.md.

Meta-rules (one line each — full text: references/meta-rules.md)

1. STIC mandatory — Signal / Technique / Invariant / Complexity on every response. Complexity in explicit Big-O notation, never prose.
2. Reevaluate before output — name a runner-up + 1-line rejection reason.
3. Cite sources — user notes first, then Tier-2/3/4 priority. URLs by symbolic name from references/url-registry.md — never hardcode.
4. Scoped output — classify recommends, doesn't solve; review recognizes, doesn't refactor. User escalates explicitly.
5. Practice-platform order — follow the 8-platform canonical order in references/meta-rules.md § Practice-platform rule.

Mandatory response structure (every DSA response)

Every flow (classify, add, template, review) and every casual DSA question emits 5 sections + Citation + closing question, in this order. Each section attaches relevant URLs by symbolic name (full per-section URL spec: references/meta-rules.md § Rule 1; per-paradigm <URL:*> map: references/source-library.md § Tier-4):

Plus: Tier label (must-have | cp-extra | advanced), Tips & Tricks (2–4 mnemonic bullets — MANDATORY), Pitfalls, Related slugs.

Compact inline example (response shape — Code Snippet section)

The Code Snippet (#2) for next-greater-element — note the 10–15 line bound, ArrayDeque over Stack, and the invariant comment:

int[] nextGreater(int[] a) {              // O(N) time, O(N) space
    int n = a.length, ans[] = new int[n];
    java.util.Arrays.fill(ans, -1);
    ArrayDeque<Integer> stk = new ArrayDeque<>();   // indices, values decreasing (invariant)
    for (int i = 0; i < n; i++) {
        while (!stk.isEmpty() && a[stk.peek()] < a[i]) ans[stk.pop()] = a[i];
        stk.push(i);
    }
    return ans;
}

Full worked end-to-end example (input → 7-element response with Citation + closing question): references/worked-examples.md. Schema + 3 more worked examples (Monotonic Stack · Binary Search on Answer · Sliding Window Variable): references/stic-card-schema.md.

Data layout

Placeholders resolved per references/path-config.md: <SKILL_ROOT> (read-only) · <SKILL_STATE> (cards/index) · <BOOKS_ROOT> (local PDFs; degrades to citation-only) · <CLAUDE_CONFIG>.

Flows (full variant specs: references/flow-details.md)

add flow — strict Invariant validation

After writing, re-read the Invariant. If it could apply to two or more different paradigms unchanged, it's too vague.

• ❌ "We keep track of the best answer so far." (Kadane, monotonic-stack, greedy, DP all fit.)
• ✅ "Stack is monotonically decreasing; each index pushed once + popped at most once → amortized O(1)."

If it fails → don't persist; ask the user to articulate the truth claim that justifies correctness.

Reference Index

Output style follows <CLAUDE_CONFIG> (default code language: Java; concise, actionable).