LeetCode Medium Problems — The Complete Strategy Guide

There is a well-documented cliff in LeetCode practice: Easy problems feel manageable, then Medium problems suddenly feel impossible. Most practitioners blame themselves — assuming they lack raw intelligence or haven't studied enough. The real cause is structural.

Easy problems are pattern-isolated. Two Sum tests hashing. Valid Parentheses tests stack recognition. Reverse a Linked List tests pointer manipulation. Each problem exercises exactly one technique in isolation, and once you recognize the technique, the implementation follows directly.

Medium problems break this isolation. They require you to chain two or three patterns together. You must recognize which patterns apply, decide in what order to apply them, and manage the complexity of their interaction. This is a fundamentally different cognitive task — not a matter of knowing more patterns, but of combining the ones you already know.

LeetCode Medium problems appear in approximately 65% of real coding interviews — solving 60-80 unique Mediums with full pattern understanding outperforms solving 200+ by rote. The compounding effect of fluent pattern combination is what makes the difference.

This guide explains why Mediums feel hard, identifies the six most common pattern combinations that appear in Mediums, gives you a tiered problem list to practice on, and walks through a repeatable 5-step process for approaching any Medium problem you haven't seen before.

The Easy-to-Medium transition difficulty comes from compound patterns: Easy uses one structure in isolation, Medium requires combining two or three. When you encounter a Medium problem and feel "stuck," you are almost always stuck at one of two levels: algorithm recognition or implementation bridging.

Algorithm recognition failure means you can see that the problem involves arrays and a target sum, but you don't connect it to the sliding window + frequency map combination required. You reach for brute force because it's the only complete solution you can visualize end-to-end. The fix is pattern inventory — deliberately learning which two-pattern combinations exist and what problem shapes trigger them.

Implementation bridging failure means you can identify the patterns abstractly — "this needs BFS plus level tracking" — but you don't know how to weave them together in code. You know the pieces but not the seams. The fix is focused practice on the transition point: the data structure that carries information from one pattern phase into the next.

A useful diagnostic: after failing a Medium, write down which patterns were involved. Then ask whether you failed to identify them (recognition gap) or failed to combine them (bridging gap). The prescription differs. Recognition gaps need more pattern exposure. Bridging gaps need more practice on problems of the same pattern pair.

Don't confuse "hard problem" with "new concept." The vast majority of Medium problems on LeetCode use patterns you have already seen in Easy problems. What is new is the combination — and combinations are learnable through deliberate practice, not through endless consumption of new techniques.

After analyzing hundreds of Medium problems, six pattern combinations account for the majority of interview-relevant questions. Learning to recognize each combination — and the seam connecting the two patterns — gives you a reusable template rather than isolated problem knowledge.

HashMap + Two Pointers appears in problems where you need to track seen elements while scanning from both ends or maintaining a window. Two Sum (#1) is the Easy baseline; Three Sum (#15) extends it by fixing one element and using two pointers for the remaining pair. The seam is the loop that fixes one variable, reducing a two-variable problem into a one-variable problem solved by two pointers.

Sliding Window + Frequency Map is the go-to combination for substring or subarray problems with character/element constraints. Longest Substring Without Repeating Characters (#3) and Minimum Window Substring (#76) both use it. The window boundary moves when the frequency map violates the constraint. Mastering how to maintain and query the map inside the window loop is the bridging skill.

BFS + Level Tracking converts graph/tree traversal results into structured output. Binary Tree Level Order Traversal (#102) is the canonical example. The seam is capturing the queue size at the start of each BFS iteration — this snapshot size tells you exactly how many nodes belong to the current level before you enqueue the next.

Stack + Greedy appears in problems that require maintaining a monotone structure while making locally optimal decisions. Daily Temperatures (#739) and Largest Rectangle in Histogram (#84) both follow this shape. The stack holds candidates; the greedy rule decides when to pop. The bridging data structure is the index stored in the stack, which lets you compute spans in O(1).

Binary Search + Custom Comparator applies when the search space isn't an explicit sorted array but a range of possible answers. Capacity to Ship Packages Within D Days and Koko Eating Bananas both binary-search over the answer domain, using a validation function as the comparator. The seam is designing the monotone predicate: "is answer X feasible?" must be answerable in O(n).

DFS + Memoization transforms exponential recursive search into polynomial dynamic programming. Coin Change (#322) and Course Schedule (#207) both use DFS that would be exponential without caching. The seam is the memoization table keyed on the recursive state. Identifying which parameters define a unique subproblem state is the critical bridging skill.

Not all Mediums are equal in difficulty or return on investment. The following tiered list prioritizes problems by their pattern-teaching value. Work through Beginner Mediums first to establish the compound-pattern mindset, then move to Core Mediums, then Advanced.

Beginner Mediums use the simplest form of each combination, with minimal implementation complexity at the seam. These are the best entry points for developing pattern-combination intuition without getting derailed by edge cases.

Core Mediums represent the most interview-frequent problems. Every serious candidate should be able to solve all of them fluently. They appear across FAANG, startup, and mid-size company interviews with high regularity.

Advanced Mediums require precise implementation, careful state management, or non-obvious reductions. They reward deep understanding of the pattern combination rather than surface-level familiarity.

Most failed attempts at Medium problems skip pseudocode. The practitioner reads the problem, tries to hold the full solution in their head, then types code that collapses under the first edge case. The 5-step process below forces the key thinking to happen before you write a single line of code.

Step 1 — Read and Restate: Read the problem twice. Restate it in your own words in one sentence. Identify the input type (array, string, graph, tree), the output type, and any constraints (size, value range, time limit). Do not skip this. Constraints often signal the intended complexity class and narrow the pattern space.

Step 2 — Identify Constraints: Check size constraints. n <= 10^4 suggests O(n^2) is borderline acceptable. n <= 10^5 requires O(n log n) or better. n <= 10^6 requires O(n). These constraints directly eliminate candidate patterns. A sliding window is O(n); DFS without memoization on a graph of size 10^5 is not viable.

Step 3 — Recall Patterns: Ask: "What patterns apply to this input/output type?" Then ask: "Which combination applies given the constraint and the problem goal?" Run through the six pattern combinations from Section 3. Map the problem shape to a combination. If nothing fits, consider reduction — can this problem be transformed into a known problem type?

Step 4 — Pseudocode: Write the algorithm in plain language before writing code. Include the data structures you'll use, the loop structure, and the seam between patterns. Pseudocode exposes logical errors cheaply. Skipping pseudocode is the single most common mistake practitioners make on Medium problems. Writing code before the logic is clear produces code that is hard to debug and impossible to explain in an interview.

Step 5 — Code and Verify: Implement the pseudocode. Test with the provided examples first, then test edge cases: empty input, single element, all-same elements, maximum size input. For graph/tree problems, test single-node and disconnected graphs. For string problems, test empty string and all-same characters.

The most common question from practitioners who are stuck is "how many more problems do I need to solve?" The answer is almost always "fewer than you think, but better than you're doing."

Quality of practice matters far more than quantity. Solving 60-80 unique Mediums with full pattern awareness — knowing why each solution works, which combination it uses, and what the bridging data structure is — outperforms solving 300+ problems by pattern-matching to memorized solutions. The difference becomes stark in novel interview questions that don't match any problem you've seen exactly.

The reason volume without depth fails: interview questions are not drawn from a fixed set. Interviewers modify problems, add constraints, or ask follow-up variations. If your understanding is shallow, any deviation breaks your solution. Deep pattern understanding generalizes. Shallow memorization does not.

A practical target: solve 25-30 Beginner and Core Mediums from the tiered list above, each to the level of full pattern articulation. Then attempt 10-15 new Mediums you haven't seen. If you can solve 60-70% of unseen Mediums within 25-35 minutes, you have sufficient Medium fluency for most technical interviews. If not, identify which pattern combinations are failing and add targeted practice in those areas.

Spaced repetition dramatically improves retention. Solving a problem once and never revisiting it creates fragile memory. Problems reviewed at increasing intervals — 1 day, 3 days, 7 days, 14 days — become genuinely internalized. The difference between a problem you can recall under pressure and one you vaguely remember is almost always spaced review.

The Easy-to-Medium cliff is real, but it is not a reflection of aptitude. It is a reflection of practice structure. Easy problems train pattern recognition in isolation. Mediums require pattern combination fluency — a skill that must be deliberately practiced, not accidentally acquired through volume.

The six pattern combinations in this guide — HashMap + Two Pointers, Sliding Window + Frequency Map, BFS + Level Tracking, Stack + Greedy, Binary Search + Custom Comparator, and DFS + Memoization — account for the majority of interview-relevant Mediums. Learning to recognize these combinations and execute their seams reliably is a finite, achievable task.

Use the tiered problem list to build fluency progressively. Apply the 5-step process to every problem you attempt — especially the pseudocode step, which is the most commonly skipped and most valuable. Track your internalized versus reference problems using spaced repetition.

With 60-80 fluent Mediums and genuine pattern combination understanding, you will approach technical interviews with the confidence that comes from real preparation — not from hoping the right problem appears, but from knowing you can handle what does.