LC Java
the other half of the tree

Why a skill and not a habit

Three ways filing Java goes wrong

None of these are hypothetical — each one has actually landed in this repo, at a scale that took a 1481-file sweep to undo. They are why the recipe is written down once instead of remembered differently every time.

One pass, no branches

Nine steps, in order

The steps never reorder and none of them is optional. Pick one to see what it does and the rule that step exists to enforce.

What lands in the tree

The house layout

Two artefacts, every time: one Java file and one edited README row. Both are shown here as they were actually written for LC 25 — the run the skill's own worked example describes.

package LeetCodeJava.LinkedList;        <- the directory, spelled out

// https://leetcode.com/problems/reverse-nodes-in-k-group/description/
                                       <- load-bearing: the coverage join reads it
import LeetCodeJava.DataStructure.ListNode;
                                       <- imported, never re-declared
/**
 * 25. Reverse Nodes in k-Group        <- number, exact title
 * Hard                                <- difficulty, own line, nothing else
 *
 * Given the head of a linked list, reverse the nodes of the list k at
 * a time, and return the modified list.
 *
 * Example 1:
 *
 * Input: head = [1,2,3,4,5], k = 2
 * Output: [2,1,4,3,5]
 *
 * Constraints:
 *
 * 1 <= k <= n <= 5000
 *
 */
public class ReverseNodesInKGroup {     <- title in PascalCase, = the file name

    // V0                               <- zero, not the letter O
    // IDEA: REVERSE IN GROUPS OF K
    /**
     * time = O(N)                      <- equals sign, not a colon
     * space = O(1)
     */
    public ListNode reverseKGroup(ListNode head, int k) {
        // edge case
        if (head == null || k <= 1) {
            return head;
        }

        int len = 0;
        ListNode dummy = new ListNode();
        dummy.next = head;
        ListNode cur = head;
        while (cur != null) { len += 1; cur = cur.next; }

        ListNode prevGroupEnd = dummy;
        cur = head;
        // NOTE !!! only reverse while a FULL group of k remains
        while (len >= k) {
            ...
        }
        return dummy.next;
    }
}

| 0025 | [Reverse Nodes in k-Group](https://leetcode.com/problems/reverse-nodes-in-k-group/) | [Python](./leetcode_python/Linked_list/reverse-nodes-in-k-group.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/LinkedList/ReverseNodesInKGroup.java) | _O(n)_ | _O(1)_ | Hard | **linked list**, `reverse in k group` | AGAIN** (2) |

    // V0-1                             <- the marker
    // IDEA: DUMMY NODE + IN-PLACE GROUP REVERSE  (gpt)
    /**
     * time = O(N)
     * space = O(1)
     */
    public ListNode reverseKGroup_0_1(ListNode head, int k) {
                                 ^^^ the method name IS the marker
        ...
    }

Arguments are inferred, not interrogated

How to call it

The slash form and plain English do the same thing. Paste a draft under the command and it becomes the solution; leave it out and the draft is usually already in ws/Workspace26.java, which is step 2's job to find.

/lc-java 25 LinkedList              # + paste your draft under it
/lc-java 239 SlideWindow

add LC 25 to leetcode_java in java
file my workspace draft
port LC 207 to java

End to end

A worked run

/lc-java 25 LinkedList with the draft picked up from the workspace — the run the hero terminal is showing, step by step and with what each one actually produced.

The file it produced is in the tree: ReverseNodesInKGroup.java.

The guardrails

What it will not do

A filing tool that quietly does more than filing is one you have to review line by line, which defeats the point of having it.

• ×Renumber a // V marker.The marker names the method, so closing a gap in the numbering renames one. Only a genuine collision is reassigned.
• ×Write clever instead of clear.The standard approach, explicit loops, real names and a comment on each non-obvious step — no stream pipelines, nested ternaries, a[0] - b[0] comparators or uncommented bit tricks.
• ×File one approach when there are several.Every solution that passes and is worth knowing gets its own // V1, // V2, … — and a second spelling of the same loop does not count as one.
• ×Add a second README row.The problem almost always has one already. Nothing in the build catches a duplicate, which is what makes it the expensive mistake.
• ×Re-derive the other columns.Complexity, difficulty and tags belong to the problem, not the language. A Java port is not a reason to touch them.
• ×Hand back code that was not compiled.A javac plus the javadoc's own examples run before anything is reported done.
• ×Touch data/progress.txt.The practice log is your own record and gets its own commit — it is also the single source for the review plan, so nothing else writes to it.
• ×Commit or push unless asked.It writes files and stops. The commit is yours to shape.

One markdown file, no dependencies

Install

SKILL.md is the whole recipe — nothing to build and no network calls, so the same source runs on any agent that takes a system prompt. Pick yours.

git clone --depth 1 https://github.com/yennanliu/CS_basics.git /tmp/cs_basics
mkdir -p ~/.claude/skills
cp -r /tmp/cs_basics/.claude/skills/lc-java ~/.claude/skills/

cd .claude/skills && zip -r lc-java.zip lc-java

## Filing a LeetCode Java solution

When asked to add an LC problem in Java, to file a draft out of the
workspace scratch file, or to port an existing Python solution, follow
`.claude/skills/lc-java/SKILL.md`.

gemini -p "Follow the recipe in .claude/skills/lc-java/SKILL.md. \
File LC 25 into LeetCodeJava/LinkedList — draft in @Draft.java"

curl -sL https://raw.githubusercontent.com/yennanliu/CS_basics/master/.claude/skills/lc-java/SKILL.md

Under the hood

What is inside

One file. The steps live there and nowhere else — this page describes them, but SKILL.md is what actually runs, so the two cannot drift into two recipes.

• SKILL.md The whole recipe — the five prime directives, the nine steps with their commands, the file layout, the README row rule, the do-not list, and the LC 25 worked example.

Gated in CI by check_skills.py — frontmatter every host can parse, the directory name pinned to the command name, and whether the links on this page still resolve.

The rest of the loop

Where it fits

/lc-java is /lc-python's counterpart: the same recipe shape, a different tree, and one README row shared between them rather than one each. /add-time-space is the one to run over a whole package once the files are in. From there the explorer indexes it, the review plan schedules it once you log the attempt, and LC Coach is the one to ask whether the solution you just filed would actually have passed.