Java · Practice

Coding Drills

100 hands-on Java problems, organised into 10 topics that build on each other. Each drill has the problem, the key insight, a step-by-step diagram, a complete compilable solution, complexity, and the bugs people usually write.

100

Drills

Topics

25+

Patterns

Overview · Arrays & Hashing · Two Pointers · Sliding Window · Binary Search · Linked Lists · Trees · Grids · Graphs · DP · Backtracking

Drills vs. LeetCode sets: these drills are about writing the logic yourself: loops, pointers, recursion, and the core techniques. For interview-style write-ups grouped by pattern, see the LeetCode Problem Sets. For the theory behind each structure, see the DSA Guide.

Section One · Roadmap

How the 10 Topics Build on Each Other

The order matters. Arrays and hashing teach you to trade memory for time. Two pointers and sliding window teach you to stop re-scanning data. Binary search teaches you to throw half the input away. Linked lists drill pointer handling, which trees then use recursively. Grids and graphs reuse the same DFS and BFS on a wider structure. Dynamic programming caches those recursions, and backtracking enumerates them. Work top to bottom the first time; after that, jump straight to whichever topic you're weakest in.

Learning path — 10 topics, 100 drills

Analogy: It works like learning an instrument. Scales come first (arrays, pointers), then chords (trees, graphs), then improvisation (DP, backtracking). Skip the scales and the improvisation sounds like noise: most DP bugs are really off-by-one array bugs, and most graph bugs are really pointer bugs.

Section Two · Topics

The 10 Topic Pages

Part 1 · Linear Structures (Drills 1–50)

01 · drills 1–12

Arrays & Hashing

Two Sum, Group Anagrams, Product Except Self, Subarray Sum = K, Majority Element, Stock I/II. HashMap complements, prefix sums, XOR, Boyer–Moore voting.

02 · drills 13–23

Two Pointers

Reverse, Move Zeroes, Remove Duplicates, Merge Sorted, Rotate, Container With Most Water, Trapping Rain Water, Next Permutation. Opposite-end and read/write pointers.

03 · drills 24–32

Strings & Sliding Window

Valid Parentheses, K-distinct substring, Character Replacement, Minimum Window Substring, Longest Palindrome, strStr, Multiply Strings. Variable windows, expand-around-center.

04 · drills 33–39

Binary Search & Intervals

Search Insert, Peak Element, Rotated Minimum, 2D Matrix, Median of Two Sorted Arrays, Merge Intervals, Meeting Rooms. Lower-bound templates, partition search, sort-then-sweep.

05 · drills 40–50

Linked Lists

Reverse, Merge, Cycle, Middle, Remove Nth, Add Two Numbers, Swap Pairs, Rotate, Odd/Even, Intersection, Partition. Dummy heads, fast/slow, pointer rewiring.

Part 2 · Trees, Graphs & DP (Drills 51–100)

06 · drills 51–64

Binary Trees & BST

Traversals, Depth, Same/Symmetric, Balanced, Path Sum, Diameter, Level Order, Zigzag, LCA, Validate BST, Build from Pre+In, Flatten. Recursion contracts and BFS levels.

07 · drills 65–71

Grids & Matrices

Flood Fill, Number of Islands, Max Area, Rotting Oranges, Shortest Path in Binary Matrix, Pacific Atlantic, Spiral Matrix. Grid DFS/BFS, multi-source BFS, reverse flow.

08 · drills 72–80

Graphs

Clone Graph, Connected Components, Valid Tree, Course Schedule, Topological Sort, Accounts Merge, Word Ladder, Kruskal MST, Dijkstra. Union-Find, Kahn's algorithm, priority queues.

09 · drills 81–94

Dynamic Programming

Climbing Stairs, House Robber, Coin Change, Decode Ways, Word Break, LIS, Max Product, Jump Game, Grid paths, Maximal Square, Subset Sum, LPS, Edit Distance. 1D, 2D and knapsack DP.

10 · drills 95–100

Backtracking & Design

Permutations, Combination Sum, Generate Parentheses, Min Stack, LRU Cache, K Closest Points. Choose/explore/un-choose, auxiliary stacks, HashMap plus doubly-linked list, heaps.

Section Three · Method

How to Work Every Drill

Every drill page follows the same six steps, and your own practice should too. The most common mistake is jumping straight to code. A few minutes on examples and a brute force almost always reveal the optimal pattern, because the optimal solution is usually the brute force with one repeated piece of work removed.

The six-step drill loop

Brute force re-scans a range for every start index

▶

Keep a window or two pointers that only move forward, so each element is visited O(1) times: O(n²) → O(n)

Brute force searches the array for a value you've already seen

▶

Store seen values in a HashMap/HashSet so each lookup is O(1): O(n²) → O(n) time, at the cost of O(n) space

Input is sorted, or the answer is monotonic (too small / big enough)

▶

Binary search on the index or on the answer: O(n) → O(log n) per query

The recursion tree solves the same sub-problem many times

▶

Memoize or build a bottom-up table: exponential → polynomial

You repeatedly need the current min/max of a changing set

▶

Use a heap (PriorityQueue) or a monotonic stack/deque: O(n) per query → O(log n) or amortised O(1)

Section Four · Recognition

Pattern Finder: From Problem Signal to Technique

Most drills give away their pattern in the problem statement. Train yourself to spot these signals in the first read. Each row links the signal to the technique and to the page that drills it.

Signal → pattern → topic page

Trap: "sorted" doesn't always mean binary search, and "substring" doesn't always mean sliding window. Sliding window needs a condition that stays valid (or invalid) as the window shrinks. Longest Palindromic Substring has no such condition, which is why it uses expand-around-center instead (drill 28).

Section Five · Budget

Read the Constraints: Your Complexity Budget

A typical judge runs roughly 10⁸ simple operations per second. The constraint on n tells you which complexity is acceptable, and that in turn narrows down which patterns are even worth trying.

Max n	Target	Typical technique	Example drills
n ≤ 10	O(n!)	Permutations, full backtracking	95 Permutations
n ≤ 20–25	O(2ⁿ)	Subsets, combination search	96 Combination Sum, 97 Parentheses
n ≤ 500	O(n³)	Interval DP, triple loops	93 Longest Palindromic Subseq. (n²)
n ≤ 10⁴	O(n²)	2D DP, expand-around-center	28 Palindrome, 86 LIS (n² version), 94 Edit Distance
n ≤ 10⁶	O(n log n)	Sort, heap, binary search	38 Merge Intervals, 79 Kruskal, 100 K Closest
n ≤ 10⁸	O(n)	Hashing, two pointers, window	1 Two Sum, 21 Rain Water, 27 Min Window
n > 10⁸	O(log n) / O(1)	Binary search, math	33 Search Insert, 37 Median (log)

Relative growth of common complexities (illustrative)

Section Six · Toolkit

The Java You'll Type Most

Most of the 100 solutions use the same dozen or so API calls. Know these without looking them up, and know their costs. For deeper coverage, see Java Collections for DSA.

Java — everyday drill toolkit

import java.util.*;

// Hashing — O(1) average
Map<Integer, Integer> freq = new HashMap<>();
freq.merge(x, 1, Integer::sum);            // count occurrences
freq.getOrDefault(x, 0);
Set<Integer> seen = new HashSet<>();
if (!seen.add(x)) { /* duplicate */ }

// Stack / Queue — use ArrayDeque, not Stack or LinkedList
Deque<Integer> stack = new ArrayDeque<>();   stack.push(x); stack.pop(); stack.peek();
Queue<int[]> q = new ArrayDeque<>();        q.offer(new int[]{r, c}); q.poll();

// Heap — O(log n) offer/poll, O(1) peek
PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> Integer.compare(a[0], b[0]));

// Arrays & strings
Arrays.sort(arr);                                // O(n log n)
Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
Arrays.fill(dp, Integer.MAX_VALUE);
char[] cs = s.toCharArray();   int[] count = new int[26];   count[c - 'a']++;
StringBuilder sb = new StringBuilder();       // never concatenate String in a loop

// Safe midpoint and overflow
int mid = lo + (hi - lo) / 2;
long sum = (long) a + b;

⚠️

Integer caching

Compare boxed Integer values with .equals(), not ==. == only works by accident for −128…127.

🧮

Overflow

lo + hi, products, and running sums overflow int. Use long or lo + (hi − lo) / 2.

🔁

Comparators

Use Integer.compare(a, b) instead of a − b. Subtraction overflows for large values of opposite sign.

Section Seven · Plan

A 4-Week Study Plan

Week	Topics	Drills	Goal
Week 1	01 · 02 · 03	1–32	Get O(n) to be your default: hash maps, pointers, windows
Week 2	04 · 05 · 06	33–64	Correct loop bounds, pointer rewiring, recursion contracts
Week 3	07 · 08	65–80	DFS/BFS from memory, topological sort, Union-Find, Dijkstra
Week 4	09 · 10	81–100	Define the state, recurrence and base case before writing any code

How to practise each drill:

Read the problem and example only. Close the solution and give yourself 20 minutes.
Write the brute force first, even if it's obvious. Then state what it repeats.
Compare your answer with the walkthrough diagram, not just the final code.
Re-solve from a blank file 3 days later. If you can't, it wasn't learned yet.
Track each drill as solved / solved-with-hint / failed, and redo failures at the end of the week.

Start here: 01 · Arrays & Hashing →

LearningTree

Java Coding Drills | 100 Problems