Rung 4 — LeetCode 100 Hard Milestone¶

Month: M4–M6 | Mode: Deliberate Tracking | Platform: GitHub + Blog

Solving 100 LeetCode problems without tracking is just grinding. Solving 100 LeetCode problems with honest, annotated tracking is deliberate practice — and the difference in what you learn is not marginal. The annotation is where the learning happens: naming the pattern forces recognition, writing what you learned forces reflection, and recording whether you needed a hint forces honesty about where the gaps actually are.

The artifact here is not the number 100. It’s the evidence that you practiced deliberately over 10 weeks, identified your own thinking patterns, and wrote a reflection that’s useful to your future self.

What It Is¶

A GitHub repository named leetcode-journey (or a structured Notion page, though GitHub is preferred for public visibility) that tracks your first 100 LeetCode problems with per-problem annotations, culminating in a reflection post published to your blog.

Not a list of solved problem titles. An annotated record with enough signal that someone reading it can understand how you’re developing as a solver.

The Problem Log¶

Per-Problem Entry Format¶

Every solved problem gets an entry in a structured log (a Markdown table or a series of Markdown entries in a log file). Each entry contains:

| # | Problem | Difficulty | Date | Time Taken | Pattern | Hint Used? | What I Learned |

Field definitions:

# — sequential number (1–100)
Problem — name + LeetCode link
Difficulty — Easy / Medium / Hard
Date — when you solved it (YYYY-MM-DD)
Time Taken — actual time from reading problem to accepted solution (be honest: “45 min”, “2 hours”, “gave up at 90 min, came back next day”)
Pattern — one of your named patterns (e.g., “two pointers”, “sliding window”, “BFS”, “DP: 0/1 knapsack”, “binary search on answer”). If you can’t name a pattern, write “unclear — revisit.”
Hint Used? — Yes / No / Editorial. No judgment, just honest tracking. “Looked at hint after 30 min stuck” is fine.
What I Learned — 1–3 sentences. Not “I learned BFS.” Something specific: “I learned that BFS on a grid requires treating each cell as a node and checking 4 neighbors — the translation from 2D coordinates to graph adjacency was the non-obvious step.”

Target Distribution¶

The 100 problems should have this approximate distribution:

Difficulty	Count	Why
Easy	30	Build pattern recognition on clean examples; these are fast (15–20 min each)
Medium	50	The core of LeetCode practice; most interview and competition problems live here
Hard	20	Push your ceiling; expect to use hints/editorials on most; the goal is understanding, not independent solve

Do not front-load all Easy problems and defer Hard. Interleave: solve 2–3 Easy, 4–5 Medium, 1–2 Hard per week. Hard problems solved with editorial understanding are more valuable than Easy problems solved quickly.

The Milestone Artifact: Reflection Post¶

When you reach problem 100, publish a blog post titled:

“100 Problems In: What I Learned About My Own Thinking”

This is the artifact that transforms a log into a portfolio rung. The log is evidence of practice. The reflection post is evidence of metacognition — that you studied yourself as a learner, not just the problems.

What the reflection post must cover:¶

Patterns you see — which pattern categories came most naturally? Which were hardest to recognize? What surprised you about the distribution of patterns across problems?
Mistakes you made repeatedly — be specific. “I kept missing the edge case where the array is empty.” “I wrote O(n²) solutions for problems that should be O(n) with two pointers.” “I consistently underestimated the complexity of my hash map implementations.”
What changed between problem 1 and problem 100 — specific behavioral changes in how you approach a problem. Not “I got better” — what does better actually look like in your process?
3 problems you’re most proud of — problems you solved independently, understood deeply, or had a significant insight on. Brief note on what made each one memorable.
One problem you still don’t fully understand — intellectual honesty. What did you look at, read the editorial for, and still feel uncertain about? This is actually a strong signal: it shows you know where your edges are.
Your current pattern recognition radar — which patterns can you now recognize reliably in < 5 minutes of reading a problem? Which still require hints?

Length: 1000–1500 words. Honest, personal, specific. Not a tutorial — a reflection.

Repository Structure¶

leetcode-journey/
├── README.md          ← Overview, stats summary, link to blog post
├── LOG.md             ← The annotated 100-problem log table
├── patterns/
│   ├── two-pointers.md      ← Notes on the pattern, problems using it
│   ├── binary-search.md
│   ├── dp-patterns.md
│   └── ...              ← One file per pattern (optional but valuable)
└── solutions/           ← Optional: clean solution files for selected problems
    ├── 001_two_sum.java
    └── ...

The patterns/ directory is optional but highly recommended. When you notice you’ve solved 5 two-pointer problems, write a single page summarizing the pattern, the recognition triggers, and the canonical problems. This becomes the raw material for the DP Handbook in Rung 6.

Acceptance Criteria¶

100 problems logged with all fields filled for each entry
Target distribution approximately met: 25–35 Easy, 45–55 Medium, 15–25 Hard
“Hint Used?” field honestly filled (no one is grading you on this — lying defeats the purpose)
Reflection blog post published on Hashnode or Dev.to by end of Month 6
Repository is public
The reflection post is specific (not generic “I learned a lot”) and honest (not “I was amazing at all of these”)

Where to Publish¶

GitHub — leetcode-journey repo, public, with the annotated log
Blog — reflection post on Hashnode/Dev.to, cross-linked from the repo README
LeetCode profile — set your LeetCode profile to public; the stats page becomes supplementary evidence

Signal It Sends¶

“This person practices deliberately, not randomly.”

Random grinding — solving whatever’s next on NeetCode 150 without thinking about why — is visible in retrospect. It produces solvers who can recognize problems they’ve seen before but struggle with variants. Annotated, pattern-tagged practice produces solvers who generalize.

The annotation log proves you were paying attention. The reflection post proves you were learning, not just solving. The combination is rare and immediately distinguishable from someone who just says “I did 100 LeetCode problems.”

Practical Notes¶

Start the log immediately. Don’t solve 20 problems and then try to fill in the log retroactively. The “what I learned” note is most accurate within 30 minutes of solving.
30 minutes rule: If you’re stuck for 30 minutes with no progress, look at the hint. Not the full editorial — the hint. If still stuck after 15 more minutes, read the editorial and understand the approach. Then close it and implement from understanding, not copying.
LeetCode premium is not required for the first 100 problems. The problems listed above are all free-tier accessible.
Quality over speed. 2 well-understood problems per study session beats 5 pattern-matched-and-forgotten problems.
The Hard problems: expect to use editorials on 15+ of the 20 Hard problems. That’s fine. Understanding a Hard problem via editorial is still understanding. Faking an independent solve in your log is not.

Timeline¶

Week	Target	Cumulative
Week 1 (M4)	10 problems (7E, 2M, 1H)	10
Week 2 (M4)	10 problems (3E, 6M, 1H)	20
Week 3 (M4)	10 problems (3E, 5M, 2H)	30
Week 4 (M4)	10 problems (2E, 6M, 2H)	40
Week 5 (M5)	10 problems (2E, 6M, 2H)	50
Week 6 (M5)	10 problems (2E, 6M, 2H)	60
Week 7 (M5)	10 problems (2E, 6M, 2H)	70
Week 8 (M5)	10 problems (2E, 6M, 2H)	80
Week 9 (M6)	10 problems (2E, 5M, 3H)	90
Week 10 (M6)	10 problems (1E, 5M, 4H)	100
Week 11 (M6)	Write + publish reflection post	Done

At 10–15 hours/week and 1–2 hours per problem (including annotation), this is achievable. Hard problems may take 2–3 hours including editorial study. Budget accordingly.

Rung 4 — LeetCode 100 Hard Milestone¶

What It Is¶

The Problem Log¶

Per-Problem Entry Format¶

Target Distribution¶

Suggested Problem Set (First 100)¶

Two Pointers (8 problems)¶

Binary Search (8 problems)¶

Linked List (6 problems)¶

Trees (12 problems)¶

Graphs (10 problems)¶

Dynamic Programming (18 problems)¶

Heap / Priority Queue (6 problems)¶

Stack / Monotonic Stack (6 problems)¶

Intervals + Miscellaneous (remaining to reach 100)¶