Amazon Coding Round Questions 2026: Patterns + Solutions

Quick answer (updated 8 June 2026): Amazon's coding rounds for SDE-1 freshers test a narrow, repeating band of DSA patterns, arrays and two-pointer, sliding window, hashing, trees and BFS/DFS, graphs (shortest path and topological sort), dynamic programming, and heaps. The online assessment usually carries two medium-to-hard problems in 90 minutes; each interview round adds one to two problems with live follow-ups. The patterns and frequency below are compiled from candidate reports across 2022 to 2025 Amazon India loops, not an official syllabus, so use them to prioritise, then confirm details in your scheduling email.

If you want to clear Amazon's coding rounds, you do not need to grind 1000 problems. You need to recognise the ten or so patterns Amazon keeps reusing and solve them cold under time pressure. This guide gives you those patterns, the round structure, and fully worked solutions.

Amazon Coding Round Structure for Freshers

Based on 2022 to 2025 candidate reports for SDE-1 India loops, the coding stages are:

Stage structure is candidate-reported (2022 to 2025 India SDE-1 loops). Partial scoring applies in the OA, so submit code that passes some test cases even if incomplete. Your scheduling email is the binding source for your specific loop.

In live rounds, the interviewer expects you to talk through your approach before coding, state the time and space complexity, and dry-run on an example. Silence while you code reads as a red flag.

The Patterns Amazon Reuses Most

This frequency table is compiled from roughly 300 Amazon India candidate OA and interview reports between 2022 and 2025. It is approximate and not exhaustive, but it is a reliable guide to where to spend your prep time.

Frequencies are candidate-reported aggregates (2022 to 2025), labelled relative not absolute. Treat arrays, sliding window, hashing, trees, and graphs as your core.

Worked Solution 1: Sliding Window

Problem: Given a string, find the length of the longest substring without repeating characters.

Approach: Maintain a window with two pointers and a hash set of characters currently in the window. Expand the right pointer; if the new character is already in the set, shrink from the left until it is removable. Track the maximum window length.

def longest_unique_substring(s):
    seen = set()
    left = 0
    best = 0
    for right in range(len(s)):
        while s[right] in seen:
            seen.remove(s[left])
            left += 1
        seen.add(s[right])
        best = max(best, right - left + 1)
    return best

Complexity: O(n) time, since each character is added and removed at most once. O(min(n, charset)) space for the set. This O(n) sliding-window shape is one of Amazon's most repeated.

Worked Solution 2: Hashing

Problem: Given an array of integers and a target k, count the number of contiguous subarrays whose sum equals k.

Approach: Use a prefix-sum hash map. For each index, the number of subarrays ending here with sum k equals the count of earlier prefix sums equal to (current prefix sum minus k).

def subarray_sum_equals_k(nums, k):
    count = 0
    prefix = 0
    seen = {0: 1}
    for x in nums:
        prefix += x
        count += seen.get(prefix - k, 0)
        seen[prefix] = seen.get(prefix, 0) + 1
    return count

Complexity: O(n) time, O(n) space. The brute-force O(n squared) double loop will time out on Amazon's larger test cases, so the prefix-sum map is the expected answer.

Worked Solution 3: Trees (BFS)

Problem: Return the level-order traversal of a binary tree as a list of lists.

Approach: Standard breadth-first search using a queue. Process the tree level by level, recording the queue size at the start of each level to group nodes correctly.

from collections import deque

def level_order(root):
    if not root:
        return []
    result = []
    q = deque([root])
    while q:
        level = []
        for _ in range(len(q)):
            node = q.popleft()
            level.append(node.val)
            if node.left:
                q.append(node.left)
            if node.right:
                q.append(node.right)
        result.append(level)
    return result

Complexity: O(n) time, each node visited once. O(w) space where w is the max level width. Be ready for the follow-up: zigzag traversal, which just alternates the insert order per level.

Worked Solution 4: Graphs

Problem: Given a grid of 1s (land) and 0s (water), count the number of islands.

Approach: Iterate the grid; on each unvisited land cell, run a DFS or BFS to sink the whole connected component, incrementing a counter once per component.

def num_islands(grid):
    if not grid:
        return 0
    rows, cols = len(grid), len(grid[0])
    count = 0

    def sink(r, c):
        if r < 0 or c < 0 or r >= rows or c >= cols or grid[r][c] != '1':
            return
        grid[r][c] = '0'
        sink(r + 1, c)
        sink(r - 1, c)
        sink(r, c + 1)
        sink(r, c - 1)

    for r in range(rows):
        for c in range(cols):
            if grid[r][c] == '1':
                count += 1
                sink(r, c)
    return count

Complexity: O(rows times cols) time and space. The common follow-up is "what if the grid is too large for recursion?", to which the answer is an iterative BFS with a queue.

Worked Solution 5: Dynamic Programming

Problem: Given coins of various denominations and a target amount, return the fewest coins needed to make that amount, or -1 if impossible.

Approach: Bottom-up DP. dp[a] holds the minimum coins for amount a. For each amount, try every coin and take the best.

def coin_change(coins, amount):
    dp = [float('inf')] * (amount + 1)
    dp[0] = 0
    for a in range(1, amount + 1):
        for c in coins:
            if c <= a:
                dp[a] = min(dp[a], dp[a - c] + 1)
    return dp[amount] if dp[amount] != float('inf') else -1

Complexity: O(amount times number of coins) time, O(amount) space. Amazon interviewers often ask you to explain why greedy fails for arbitrary denominations, so be ready with a counterexample like coins [1, 3, 4] for amount 6.

Worked Solution 6: Heaps

Problem: Return the k most frequent elements in an array.

Approach: Count frequencies in a hash map, then use a min-heap of size k over (frequency, value) pairs, evicting the smallest as you go.

import heapq
from collections import Counter

def top_k_frequent(nums, k):
    freq = Counter(nums)
    heap = []
    for val, f in freq.items():
        heapq.heappush(heap, (f, val))
        if len(heap) > k:
            heapq.heappop(heap)
    return [val for f, val in heap]

Complexity: O(n log k) time, O(n) space. The bucket-sort variant achieves O(n) and is a strong follow-up answer if the interviewer pushes for better than log k.

How to Prepare in 6 Weeks

• Weeks 1 to 2: Arrays, two-pointer, sliding window, hashing. Solve 40 problems, mostly easy to medium. Re-derive each pattern from scratch.
• Weeks 3 to 4: Trees and graphs. BFS, DFS, LCA, topological sort, Dijkstra, number-of-islands family. 30 medium problems.
• Week 5: Dynamic programming and heaps. Coin change, LCS, knapsack, top-k, merge-k. 20 problems.
• Week 6: Timed mock OAs. Three full 90-minute sessions with two problems each. Practice narrating your approach out loud for live rounds.

Pair this with the 7-day coding round crash plan 2026 if your interview is close.

Why These Patterns and Not Others

It is worth understanding why Amazon's coding rounds concentrate on this particular band of patterns, because it helps you prioritise honestly rather than trying to prepare everything. Amazon's interviews are designed to predict on-the-job performance for an SDE who will work on large-scale, data-heavy systems, so the questions favour patterns that show whether you can reason about efficiency at scale and handle data structures fluently. Arrays, two-pointer, sliding window, and hashing dominate because they are the everyday tools for processing collections efficiently, and they cleanly distinguish a candidate who reaches for an O(n) solution from one who writes an O(n squared) loop without noticing.

Trees and graphs appear frequently because so much real-world data is hierarchical or networked, and the ability to traverse it correctly with BFS and DFS, or to reason about shortest paths and dependencies, is a core SDE skill. Dynamic programming shows up in the harder slots precisely because it tests whether you can break a problem into overlapping subproblems and reason about optimal substructure, which correlates with the kind of careful decomposition senior engineering work demands. Heaps and priority queues round out the set because top-k and streaming problems are common in practice.

The practical implication is to build genuine fluency in the high-frequency patterns first, until you can implement them cold and explain their complexity, before spreading into rarer territory. A candidate who can confidently and clearly solve a medium array, tree, or graph problem under time pressure is better positioned than one who has shallowly touched fifty topics. Depth in the patterns Amazon actually reuses beats breadth across patterns it rarely asks.

How to Communicate in Amazon Live Coding Rounds

In Amazon's live interview rounds, how you arrive at the solution matters as much as the solution itself, and candidates who code in silence consistently underperform candidates with identical answers who narrate well. The interviewer is scoring your problem-solving process and, often, a Leadership Principle or two attached to the round, so treat the session as a collaboration rather than a test.

A reliable structure is to first restate the problem and clarify assumptions, the input ranges, whether the array can be empty, whether values can be negative, what to return on no answer. Then state your approach out loud, including the brute force if that is your starting point, and the time and space complexity, before you write any code. As you code, narrate what each part does, and when you finish, dry-run on a small example to catch your own bugs. If the interviewer offers a hint, take it gracefully and incorporate it; resisting a useful nudge reads as inflexibility, while using one well is a positive signal.

This communication discipline connects to Amazon's Leadership Principles. Diving into the root cause of a tricky case shows Dive Deep, calmly handling an ambiguous requirement shows Bias for Action and Earn Trust, and openly correcting your own mistake mid-solution shows Ownership. Because most loop rounds blend coding with behavioural probing, the way you conduct yourself during the coding portion already feeds the interviewer's view of how you would work on the team. Practising out loud, ideally in mock interviews, is the highest-leverage preparation for these rounds.

Related Resources

• Amazon online assessment 2026, the OA pattern and section timing in detail
• Amazon off campus drive 2026, eligibility, timeline, and full hiring cycle
• Amazon leadership principles interview 2026, the behavioural half of the loop
• LeetCode questions Amazon 2026, curated problem set by pattern
• How to crack Amazon fresher coding round, strategy and time management
• Amazon placement papers 2026, solved past-drive papers

FAQs: Amazon Coding Round Questions 2026

Q: How many coding problems are in the Amazon OA?

Most 2022 to 2025 candidate reports describe two DSA problems of medium-to-hard difficulty in a 90-minute window, plus a work-style survey. Partial scoring applies, so submit code that passes some test cases even if you cannot solve both fully. Confirm the format in your assessment invite.

Q: What is the most common topic in Amazon coding rounds?

Across candidate reports, arrays with two-pointer or sliding window, hashing, and trees and graphs appear most often. Dynamic programming shows up in the harder OA slots and senior rounds. Prioritise the high-frequency patterns first.

Q: Does Amazon allow any programming language in the coding rounds?

Candidates typically report a choice of C++, Java, and Python. Pick the language you are fastest and most accurate in; the interviewer cares about correctness and complexity, not which language you use.

Q: Do I need to solve problems optimally to pass?

A working brute force that passes some test cases beats a broken optimal attempt because of partial scoring in the OA. In live rounds, state the brute force, then improve to the optimal and explain the trade-off. Interviewers value the reasoning, not just the final code.

Q: How important is talking through my approach in live rounds?

Very. Coding in silence is a common reason strong candidates underperform. State your approach, the complexity, and a dry-run before you code, and narrate as you go. The interviewer is evaluating your problem-solving process, not just the final solution.

Q: Are system design questions asked to freshers?

SDE-1 fresher loops occasionally include a light low-level design or simple high-level design discussion, but the weight is on DSA. Senior loops are design-heavy. Focus your fresher prep on the DSA patterns above.

Q: Should I narrate my approach before coding in Amazon rounds?

Yes, always. State your approach and complexity, and ideally the brute force first, before writing code. The interviewer scores your problem-solving process, and silent coding loses signal even when your final solution is correct.

Q: How do Leadership Principles show up in coding rounds?

Many loop rounds attach two to three behavioural questions to the coding portion, and your conduct while coding (handling ambiguity, owning mistakes, diving deep on edge cases) also feeds the Leadership Principle assessment. Treat coding rounds as both technical and behavioural.

Q: What is the single most common Amazon coding pattern to master first?

Arrays with the two-pointer and sliding-window techniques, closely followed by hashing. They appear in a large share of OAs and interviews and unlock many medium problems in linear time, so make them automatic before moving to trees, graphs, and DP.