Rung 2 — The DSA GitHub (150 Solutions + Pattern Tags)

Target month: Shipped by end of M4 = end of October 2026 Calendar deadline: October 31, 2026 Phase alignment: Phase 02 — Core Java DSA Signal level: study-signal → proves you can pass the DSA rounds MNCs and product companies use as their default filter

What It Is

A public GitHub repository with 150 DSA problems solved in Java 21, organized by pattern (not by problem source or difficulty). The directory layout mirrors how you actually think about study problems:

dsa-in-java/
├── 01_arrays_two_pointer/
├── 02_sliding_window/
├── 03_binary_search/
├── 04_linked_lists/
├── 05_stacks_and_monotonic_stacks/
├── 06_trees_dfs_bfs/
├── 07_graphs/
├── 08_heap_and_top_k/
├── 09_backtracking/
├── 10_greedy/
├── 11_dp_1d/
├── 12_dp_2d/
└── 13_intervals_and_scheduling/

Each solution file follows a strict template:

/*
 * Problem: LeetCode 3 — Longest Substring Without Repeating Characters
 * Pattern: Sliding Window (variable-size, expand-and-contract)
 * Time:  O(n) — each char enters and exits the window at most once
 * Space: O(k) where k = charset size
 * Difficulty: Medium
 * First solved: 2026-09-14 in 22 min
 * Notes: Classic "seen index + left pointer" variant. See sibling problem #159 for K-distinct.
 */
public class LongestSubstringWithoutRepeating {
    public int lengthOfLongestSubstring(String s) { ... }
}

Each pattern directory has its own README.md explaining the pattern in your own words, listing every problem inside, and linking to the one problem in that folder you’d re-solve if you had 30 minutes to review the pattern. That “canonical” problem is starred in the README.

The top-level README.md is a coverage matrix: rows are patterns, columns are difficulty (Easy / Medium / Hard), cells show how many problems you’ve solved in that cell.

Where To Publish

  • Repo: github.com/RaghulR2003/dsa-in-java — public, pinned

  • Announced: LinkedIn post at problem #50, #100, and #150 milestones. Each post shows the updated coverage matrix as a graphic.

  • LeetCode profile: Link the LeetCode profile in the repo README. Match your LeetCode display name to your GitHub handle so recruiters can find both.

  • Cross-link: From your portfolio landing page (Rung 11), the DSA repo is one of the six pinned tiles.

Acceptance Criteria

  • Repo exists, public, pinned on GitHub profile

  • 150 problems total, distributed across at least 12 of the 13 pattern folders

  • Every solution file has the header block (Problem / Pattern / Time / Space / Difficulty / First-solved date / Notes)

  • Every pattern folder has its own README with a written-in-your-words explanation of the pattern (200-400 words), the problem list, and one “canonical” starred problem

  • Top-level README has a coverage matrix showing pattern × difficulty counts

  • Every solution has at least 3 JUnit 5 test cases: happy path, edge case, large input

  • GitHub Actions runs the full test suite on push; badge is green

  • Commit history spans at least 12 weeks with commits on 60+ different days

  • At least 30% of problems (~45) are Medium difficulty, at least 15% (~23) are Hard

  • Repo has a PROGRESS.md you update weekly with the count and the pattern you’re currently drilling

Signal It Sends

  • You’ve done the reps. 150 problems in 3 months is real study prep, not toy prep. It’s roughly the threshold where MAANG-tier onsites become passable.

  • You think in patterns, not problems. The by-pattern folder structure signals meta-cognition. Anyone who has assessed Java candidates knows the difference between “I solved 300 LeetCodes” and “I understand 13 patterns and can recognize which one applies.”

  • You can articulate. The per-pattern README is the proof. If you can teach the pattern in 300 words, you can also explain it on a whiteboard.

  • You test your solutions. Most DSA repos on GitHub are untested. Yours is not. That single fact separates you from 90% of the corpus.

Common Failure Modes

  • The Bulk-Import Trap. You copy 150 solutions from a solutions site over one weekend. Zero commit story, zero understanding. Any study partner who spot-checks by asking “walk me through this solution” catches you in 30 seconds. Solve them yourself, first pass, then optimize.

  • The All-Easy Trap. 150 problems that are all Easy is worth less than 60 problems weighted toward Medium and Hard. Enforce the 30% Medium / 15% Hard minimum from day one.

  • The Perfect-Solution Trap. You refuse to commit until the solution is optimal. Commit brute force first with the header noting “first pass: O(n²), see v2 for O(n)”, then commit v2. This makes the learning visible.

  • The Random-Grind Trap. You solve whatever LeetCode’s daily happens to be. After 3 months you have 90 problems and no pattern coverage. Solve by pattern, not by daily feed. Pick a pattern folder for the week and fill it in.

  • Not linking LeetCode. Recruiters filter GitHub and LeetCode. Cross-linking doubles your discoverability at zero cost.

Time Estimate

At 150 problems over M3-M4 (approximately 8 weeks, roughly Sept 1 to Oct 31, 2026):

  • Easy problems (~80): 20 min average × 80 = ~27 hours

  • Medium problems (~45): 45 min average × 45 = ~34 hours

  • Hard problems (~25): 90 min average × 25 = ~37 hours

  • Pattern READMEs (13 folders): 45 min each = ~10 hours

  • Coverage matrix, CI, top-level README: ~4 hours

  • Test writing: ~15 hours (10 min average per problem)

  • Total: ~127 hours over 8 weeks = ~16 hours/week

This is the most time-expensive rung before Rung 8. Plan for it. If you’re only doing 10 hrs/week, extend to 12 weeks and start earlier (mid-August).

Prerequisites

  • All files in 02_core_java_dsa/ read and internalized

  • Rung 1 shipped (you have the muscle memory to write Java without stumbling on syntax)

  • LeetCode account created and profile customized

  • IntelliJ IDEA with a LeetCode-friendly template file

Stretch Goals (Optional)

  1. Write a patterns.md cheatsheet at repo root — one page, 13 patterns, three sentences each, ideal for pre-study review. This becomes your personal pre-study warm-up sheet.

  2. Add a PROBLEMS_BY_COMPANY.md cross-referencing solutions to companies that ask them (from LeetCode’s company tags). Recruiters love this.

  3. Publish one dev.to or Hashnode post per pattern (13 posts total, but you can do the top 5 patterns): “Sliding Window in Java 21 — the 5 problems you must know.” Each post links back to the repo. This is a compounding SEO play.

Return to README.md · Next: 03_rung3_minicollections_library.md