LC Add
solved → filed

Why a skill and not a habit

Three ways filing a solution goes wrong

None of these are hypothetical — each one has actually landed in this repo, and each one is invisible in a diff. They are why the recipe is written down once instead of remembered differently every time.

One pass, no branches

Seven 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 Python file and one README row. Both are shown here as they were actually written for LC 4038 — the run the skill's own worked example describes.

"""                                    <- docstring first, before any import

4038. Count Integers Appearing in a Single Block
Easy                                   <- number, exact title, difficulty

An integer x is called special if all occurrences of x in nums
appear in a single contiguous block.

Example 1:

Input: nums = [1,1,2,2,3]

Output: 3
...
"""

# V0                                   <- the canonical solution
# IDEA : HASH MAP {val : [idx_1, idx_2, ....]}
#
#   collect every index a value lands on, then a value is special
#   ONLY if its indices are consecutive.
#
#   the cheap way to test "consecutive" is NOT to walk the list, but
#   to compare the span against the count:
#
#      last_idx - first_idx + 1 == number_of_occurrences
#
#   e.g. nums = [1,2,1] -> idx of 1 = [0,2] -> 2 - 0 + 1 = 3 != 2
#
# time = O(n), space = O(n)             <- last comment before the code
from collections import defaultdict


class Solution(object):                 <- Python 2 style, like the whole tree
    def countSpecialIntegers(self, nums):
        """
        :type nums: List[int]           <- kept: these get pasted back into LC
        :rtype: int
        """
        # edge
        if not nums:
            return 0

        my_map = defaultdict(list)
        for i in range(len(nums)):
            my_map[nums[i]].append(i)

        cnt = 0
        for k in my_map:
            indices = my_map[k]
            # NOTE !!! span == count  <=>  indices are consecutive
            if indices[-1] - indices[0] + 1 == len(indices):
                cnt += 1
        return cnt

| 4038 | [Count Integers Appearing in a Single Block](https://leetcode.com/problems/count-integers-appearing-in-a-single-block/) | [Python](./leetcode_python/Hash_table/count-integers-appearing-in-a-single-block.py) | _O(n)_ | _O(n)_ | Easy | **hash table**, hashmap, `span == cnt` trick, first/last idx, LC weekly | AGAIN(1) |

# V0-1
# IDEA : ONE PASS, KEEP ONLY (first_idx, last_idx, count)
#
#   same "span == count" check as V0, but there is no need to KEEP
#   every index : first, last and the count are all the check reads
#
#   -> still O(n) space, but O(distinct) instead of O(n) list cells
#
# time = O(n), space = O(k), k = number of distinct values
class Solution2(object):                <- so the file still imports
    def countSpecialIntegers(self, nums):
        info = {}
        for i, v in enumerate(nums):
            if v not in info:
                info[v] = [i, i, 1]
            else:
                info[v][1] = i
                info[v][2] += 1
        return sum(1 for first, last, cnt in info.values()
                   if last - first + 1 == cnt)

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 V0; leave it out and the draft is usually already in the contest scratch file, which is step 1's job to find.

/lc-add 4038 Hash_table          # + paste your draft under it
/lc-add 239 Sliding_Window

add LC 4038 to leetcode_python/Hash_table/
file yesterday's contest Q1
add this solution and update the README

End to end

A worked run

/lc-add 4038 Hash_table with a draft pasted under it — 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: count-integers-appearing-in-a-single-block.py.

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.

• ×Rewrite your approach into its own.A pasted draft gets its bugs fixed and keeps its idea. The bug you hit is the thing worth seeing fixed.
• ×Hand back untested code.The docstring's own examples plus the edges 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.
• ×Downgrade a status you set.AGAIN(1) is for a first pass. An OK you earned stays OK.
• ×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-add ~/.claude/skills/

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

## Filing a LeetCode solution

When asked to add an LC problem to the repo, to file a problem just
solved, or to wire an existing solution file into README, follow
`.claude/skills/lc-add/SKILL.md`.

gemini -p "Follow the recipe in .claude/skills/lc-add/SKILL.md. \
File LC 4038 into leetcode_python/Hash_table/ — draft in @draft.py"

curl -sL https://raw.githubusercontent.com/yennanliu/CS_basics/master/.claude/skills/lc-add/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 seven steps with their commands, the file layout, the README row shape, the do-not list, and the LC 4038 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-add is the step right after you solve something — it turns a scratch draft into a file the rest of the site can see. From there the explorer indexes it, the review plan schedules it once you log the attempt, suggest review decides when it is owed another look, and LC Coach is the one to ask whether the solution you just filed would actually have passed.