Amazon Technical Questions 2025 - DSA Problems & System Design with Solutions

Amazon Technical Questions - Complete Guide

Practice with Amazon technical questions covering DSA problems, system design concepts, and coding fundamentals. These questions are representative of what you’ll encounter in Amazon’s online assessment and technical interviews.

What’s Included:

• Coding Problems: Arrays & Strings, Graphs & Trees, Bit Manipulation & DP
• System Design Questions: OOP and scalable system design problems
• Detailed Solutions: Step-by-step code explanations in Java/C++
• Practice Tips: Strategies for solving Amazon interview questions effectively

Amazon Placement Papers 2024

Access 2024 Amazon placement paper questions with solutions and exam pattern analysis.

View 2024 Papers →

Amazon Placement Papers 2025

Practice latest 2025 Amazon placement paper questions with updated patterns.

View 2025 Papers →

Complete Amazon Guide

Access complete Amazon placement papers guide with eligibility, process, and preparation strategy.

View Complete Guide →

Sample Amazon Questions with Solutions

Coding/DSA

Arrays & Strings

Two Sum Variant

Problem: Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target. You may assume that each input would have exactly one solution, and you may not use the same element twice. You can return the answer in any order.

Example: nums = [2, 7, 11, 15], target = 9. Output: [0, 1]

Code: (Java/C++)

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if (map.containsKey(complement)) {
                return new int[]{map.get(complement), i};
            }
            map.put(nums[i], i);
        }
        return new int[]{};
    }
}

Sliding Window Maximum

Problem: You are given an array of integers nums, there is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves right by one position.

Example: nums = [1,3,-1,-3,5,3,6,7], k = 3. Output: [3,3,5,5,6,7]

Code: (Java/C++)

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int n = nums.length;
        if (n == 0 || k == 0) return new int[0];

        int[] result = new int[n - k + 1];
        Deque<Integer> deque = new ArrayDeque<>();

        for (int i = 0; i < n; i++) {
            // Remove indices that are out of the current window
            if (!deque.isEmpty() && deque.peekFirst() == i - k) {
                deque.pollFirst();
            }

            // Remove indices whose corresponding values are less than nums[i]
            // because they will not be the maximum in the current window
            while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
                deque.pollLast();
            }

            deque.offerLast(i);

            // The first element in the deque is the maximum for the current window
            if (i >= k - 1) {
                result[i - k + 1] = nums[deque.peekFirst()];
            }
        }
        return result;
    }
}

String Compression

Problem: Given an array of characters chars, compress it using the following algorithm:

If the character count is 1, append the character. If the character count is greater than 1, append the character followed by the count.

Example: chars = [“a”,“a”,“b”,“b”,“c”,“c”,“c”]. Output: [“a”,“2”,“b”,“2”,“c”,“3”]

Code: (Java/C++)

class Solution {
    public int compress(char[] chars) {
        int writeIndex = 0;
        int count = 1;

        for (int i = 1; i <= chars.length; i++) {
            if (i < chars.length && chars[i] == chars[i - 1]) {
                count++;
            } else {
                chars[writeIndex++] = chars[i - 1];
                if (count > 1) {
                    String countStr = String.valueOf(count);
                    for (char c : countStr.toCharArray()) {
                        chars[writeIndex++] = c;
                    }
                }
                count = 1;
            }
        }
        return writeIndex;
    }
}

Graphs & Trees

Clone Graph

Given a node from a graph, return a deep copy.

Lowest Common Ancestor

Find LCA in a binary tree.

Word Ladder

Shortest transformation sequence from beginWord to endWord.

Bit Manipulation & DP

Bitmasking Subsets

Find all subsets of a set using bitmasking.

DP on Trees

Maximum path sum in a binary tree.

System Design (SDE-1/2)

Design a Bookstore System

Classes, objects, and methods for book search/count.

Design a Live Video Platform

High-level and low-level architecture for scalable video streaming.

Practice More Amazon Interview Questions →

Related Resources

• Amazon Placement Papers - Complete guide with eligibility, process, and preparation strategy
• Amazon Placement Papers 2024 - Previous year questions and solutions
• Amazon Placement Papers 2025 - Latest questions and patterns

Ready to practice more? Focus on solving these Amazon technical questions daily. Start with arrays and strings, then gradually move to graphs, trees, and system design questions. Practice coding problems in Java, C++, or Python to prepare for technical interviews.

Last updated: November 2025