30 Amazon LeetCode Interview Questions for 2026

See the 30 Amazon LeetCode interview questions most often reported in 2026, plus the patterns, LP prep, and study plan to focus your practice.

Amazon LeetCode interview questions: 30 most asked (2026)

Amazon's SDE loop includes two to three coding rounds, at least one system design round (SDE-2 and above), and a full behavioral loop built around Leadership Principles. Most candidates spend their prep time on the wrong problems. Amazon leetcode interview questions cluster around a small set of patterns, and the questions that actually show up in the loop are surprisingly predictable. This guide covers the 30 most-asked problems, the patterns behind them, and a study plan that respects your time.

How Amazon's coding interview actually works

The loop format

Amazon's on-site (or virtual on-site) loop typically runs four to five rounds in a single day:

• Two to three coding rounds — 45 to 60 minutes each, LeetCode-style problems, whiteboard or shared editor
• One system design round — SDE-2 and above; sometimes replaced with a second coding round for SDE-1
• One to two behavioral rounds — structured around Amazon's Leadership Principles, STAR format expected
• A "bar raiser" round — one interviewer from outside the hiring team, usually covering a mix of coding and behavioral

Coding rounds lean heavily on medium-difficulty problems. Big tech companies mostly ask mediums, with some easy warm-ups and rarely a hard — Amazon fits that pattern.

What "LeetCode style" means at Amazon

Amazon doesn't always use verbatim LeetCode problems. Questions are often reworded, wrapped in an Amazon-specific scenario (think: "design a feature for the shopping cart" that reduces to a known data-structure problem), or slightly modified. The substance is the same; the framing changes. Pattern recognition matters more than memorizing specific problem text.

The 7 patterns Amazon tests most

Amazon's coding questions cluster around a small set of patterns. Knowing these is more efficient than solving 300+ random problems.

• Arrays and two pointers — the most common starting point; prefix sums, in-place manipulation, pair-finding
• Sliding window — substring and subarray problems where you maintain a moving window of valid elements
• Trees and graph traversal (DFS/BFS) — binary trees, n-ary trees, grid traversal, connected components
• Binary search — classic sorted-array search plus variants on search space (e.g., "minimum capacity to ship packages")
• Dynamic programming — subsequences, knapsack variants, grid paths, string matching
• Linked lists — reversal, merge, cycle detection, reordering
• Sorting and searching — interval merging, top-K problems, custom comparators

These seven pattern families cover the vast majority of what Amazon asks in coding rounds. The 30 problems below are organized by how often they appear.

Amazon LeetCode interview questions: the 30 most asked

These are drawn from community-reported Amazon interview experiences and tagged question banks. The tier groupings reflect how frequently each problem appears in reported Amazon loops — not statistically verified frequency rankings, but consistent community signal.

Tier 1 — High frequency, must know

These appear repeatedly across reported Amazon loops. If you only have two weeks, focus here.

• Two Sum (arrays / hash map)
• Longest Substring Without Repeating Characters (sliding window)
• LRU Cache (design / hash map + doubly linked list)
• Number of Islands (BFS/DFS on grid)
• Merge Intervals (sorting / intervals)
• Top K Frequent Elements (heap / bucket sort)
• Binary Tree Level Order Traversal (BFS on tree)
• Product of Array Except Self (arrays / prefix-suffix)
• Reorder List (linked list / two pointers)
• Course Schedule (topological sort / graph)
• Trapping Rain Water (two pointers / stack)
• Word Ladder (BFS on graph)

Tier 2 — Commonly seen at SDE 1 and SDE 2

These round out your preparation and cover patterns that Tier 1 doesn't fully exercise.

• Minimum Window Substring (sliding window / hash map)
• Serialize and Deserialize Binary Tree (tree / BFS or DFS)
• Word Search II (trie / backtracking)
• Alien Dictionary (topological sort)
• Find Median from Data Stream (two heaps)
• Design Hit Counter (design / queue)
• Kth Largest Element in an Array (quickselect / heap)
• Clone Graph (BFS/DFS / hash map)
• Decode Ways (dynamic programming)
• Jump Game (greedy / dynamic programming)

Tier 3 — Worth one pass if time allows

These tend to appear at senior levels or as bar-raiser questions.

• Regular Expression Matching (dynamic programming / recursion)
• Burst Balloons (interval DP)
• Edit Distance (dynamic programming)
• The Skyline Problem (heap / sweep line)
• Max Points on a Line (geometry / hash map)
• Count of Smaller Numbers After Self (merge sort / BIT)
• Longest Increasing Subsequence (dynamic programming / binary search)
• Sliding Window Maximum (deque / monotonic queue)

One data point worth keeping in mind: one engineer who landed multiple offers completed around 450 problems but believes 150–200 well-practiced problems would have been enough. Another source estimates that 500 problems at 45 minutes each takes roughly 375 hours. The tier list above is designed to get you the highest return on the first 100–150 problems you solve.

How to study Amazon LeetCode questions without grinding blindly

Set a realistic timeline

Focused prep over 6–8 weeks is achievable if you're working through patterns deliberately. A longer route — 2–3 months at 2–3 hours per day — works if you're starting from scratch on data structures. Either way, aim for 150–200 problems practiced well, not 500 rushed.

Use a pattern first approach

Learn the pattern, then solve 4–5 problems that use it before moving on. After each problem, ask: "What pattern did this test, and would I recognize it if the wording changed?" If the answer is no, do another problem in the same family.

A useful ratio: roughly 1 easy for every 3 mediums for every 1 hard. Mediums are the main interview type at Amazon.

Practice under interview conditions

Timed sessions. Think aloud. No IDE autocomplete. The gap between knowing a solution and explaining it under pressure is where most candidates lose points — not on the algorithm itself.

Mock interviews close that gap faster than solo practice. Verve AI's Interview Copilot lets you run timed mock coding sessions with real-time feedback — practice the way Amazon will actually test you, not the way you study alone. Try it free.

Amazon LeetCode interview questions and Leadership Principles — they're connected

Amazon's loop pairs coding rounds with LP behavioral rounds. Strong coding alone isn't enough. Two separate LeetCode community threads report that "90%+ of recent Amazon behavioral questions" come from the standard LP question bank. The coding bar gets you into the conversation; the LP bar determines whether you get the offer.

Amazon currently has 16 Leadership Principles:

• Customer Obsession
• Ownership
• Invent and Simplify
• Are Right, A Lot
• Learn and Be Curious
• Hire and Develop the Best
• Insist on the Highest Standards
• Think Big
• Bias for Action
• Frugality
• Earn Trust
• Dive Deep
• Have Backbone; Disagree and Commit
• Deliver Results
• Strive to be Earth's Best Employer
• Success and Scale Bring Broad Responsibility

The last two were added in 2021. Some older prep lists still show 14 — make sure yours is current.

Practical advice from candidates who've been through the loop: prepare 4–6 STAR stories that flex across multiple LPs rather than one story per principle. A single strong project story can cover Ownership, Deliver Results, and Dive Deep if you frame it correctly. Community reports also note that SDE-1 candidates are less heavily tested on Hire and Develop the Best, Frugality, and Are Right, A Lot — so if you're interviewing at the new-grad level, prioritize the others.

Quick reference study plan for Amazon LeetCode prep

• Weeks 1–2: Arrays, strings, two pointers, sliding window. Work through Tier 1 problems in these families. One mock interview at the end of week 2.
• Weeks 3–4: Trees, graphs, DFS/BFS, binary search. Mix Tier 1 and Tier 2 problems. Refine one LP story per week.
• Weeks 5–6: Dynamic programming, linked lists, design problems. Tier 2 and Tier 3 problems. One mock interview per week. Finalize your LP story bank.
• Ongoing: One mock interview per week minimum. One LP story refined per week. Review mistakes from previous weeks rather than adding new problems.

Verve AI's mock interview tool lets you run a full Amazon-style loop — coding rounds with real-time feedback and behavioral rounds scored against STAR structure. Use it for your weekly mock sessions instead of practicing alone. Start a free mock interview.

The short version

Amazon's coding bar is high but predictable. The patterns repeat. The LP questions repeat. The candidates who pass are the ones who practiced the right things under realistic conditions — not the ones who solved the most problems.

Verve AI's Interview Copilot helps you practice both sides of the Amazon loop: code explanations that sound like a real interview, and LP answers structured in STAR format with feedback you can act on. Try it free today.