Amazon SDE Intern Interview Cracking — Three Stages + Three Classics (LRU / Word Ladder II / Insert-Delete-GetRandom)

Amazon hires more SDE interns in North America than almost any other company, and at the same time runs the most stable question bank and clearest process. Unlike Google's creativity-heavy prompts or Meta's difficulty arms race, Amazon wants to see whether you can get the classic data-structure problems right and wrap your project history in Leadership Principles language. This walkthrough breaks one full SDE Intern VO into three stages and unpacks three high-frequency problems — LRU Cache, Word Ladder II, Insert/Delete/GetRandom O(1) — down to hidden-test edges.

Three-stage map

Stage 1  Application + resume screen        (1-2 weeks)
Stage 2  Online Assessment double gate       (2-3 weeks)
            ├─ OA1: Coding (2 Mediums, 70 min)
            └─ OA2: Workstyle Survey + Logic
Stage 3  Tech Onsite + Behavioral             (1-2 weeks)
            ├─ Coding × 2-3 (45 min each)
            ├─ Behavioral × 1-2 (LP-based)
            └─ Optional: System Design (rare for Junior interns)

The intern loop typically lands in 4-6 weeks. OA1 pass rate ~30-40%, OA1+OA2 combined ~25%, end-to-end onsite-to-offer ~12-15%.

Stage 1 — Application + resume screen

Amazon's resume filter is structured-keyword matching:

• Required: Java / Python / C++, Data Structures, Algorithms, Git, Linux
• Bonus: any AWS / distributed systems / microservices OSS contribution
• Implicit LP signals: Customer Obsession (user metrics), Ownership (end-to-end responsibility), Bias for Action (rapid shipping)

Don't pile your resume as "school → courses → coursework." Pile it as "project → what I did → user/impact numbers."

Stage 2 — Online Assessment double gate

OA1 Coding

Usually 2 problems, 70 minutes. LeetCode Easy-Medium, themes:

• Array / string simulation
• BFS / DFS graph traversal
• Light DP
• Priority-queue scheduling

Trait: prompts wrap themselves in Amazon business contexts (orders, warehouses, robots, membership). Algorithms aren't hard, but you need to parse business semantics fast.

OA2 Workstyle Survey

Amazon's quantified LP test. Each question forces "in scenario X, do you lean A or B?" with each side mapped to an LP. Tip: pick the answer closest to your actual style — don't optimize toward LPs, because LPs can conflict and over-tilting one shows up as gaming.

Stage 3 — Tech Onsite, three classic problems

Classic 1: LRU Cache (always)

Design an LRU cache supporting get(key) and put(key, value) in O(1). Evict the least recently used when capacity is exceeded.

Idea: HashMap + doubly linked list.

• HashMap: key → list node
• Doubly linked list: usage order (head = newest, tail = oldest)

class Node:
    __slots__ = ("key", "val", "prev", "next")
    def __init__(self, key=0, val=0):
        self.key, self.val = key, val
        self.prev = self.next = None

class LRUCache:
    def __init__(self, capacity: int):
        self.cap = capacity
        self.map: dict[int, Node] = {}
        self.head, self.tail = Node(), Node()
        self.head.next, self.tail.prev = self.tail, self.head

    def _remove(self, node: Node) -> None:
        node.prev.next, node.next.prev = node.next, node.prev

    def _add_front(self, node: Node) -> None:
        node.prev, node.next = self.head, self.head.next
        self.head.next.prev = node
        self.head.next = node

    def get(self, key: int) -> int:
        if key not in self.map:
            return -1
        node = self.map[key]
        self._remove(node)
        self._add_front(node)
        return node.val

    def put(self, key: int, value: int) -> None:
        if key in self.map:
            node = self.map[key]
            node.val = value
            self._remove(node)
            self._add_front(node)
            return
        if len(self.map) == self.cap:
            lru = self.tail.prev
            self._remove(lru)
            del self.map[lru.key]
        node = Node(key, value)
        self.map[key] = node
        self._add_front(node)

Complexity: O(1) for every operation.

What Amazon reviewers grade:

• Use of sentinel head/tail (no boundary special cases)
• __slots__ style space optimization (bonus, not required)
• In put, check existence before evicting — wrong order miscounts capacity

Classic 2: Word Ladder II (the hardest)

Given beginWord, endWord, and a dictionary, change one letter per step (each intermediate word must be in dictionary). Return all shortest transformation sequences.

Idea: BFS to find shortest length while building a parents map; DFS to reconstruct paths. A pure DFS would explode exponentially.

from collections import defaultdict, deque

def find_ladders(begin: str, end: str, word_list: list[str]) -> list[list[str]]:
    words = set(word_list)
    if end not in words:
        return []

    parents: dict[str, set[str]] = defaultdict(set)
    layer = {begin}
    found = False
    while layer and not found:
        words -= layer
        next_layer: dict[str, set[str]] = defaultdict(set)
        for w in layer:
            for i in range(len(w)):
                for c in "abcdefghijklmnopqrstuvwxyz":
                    nw = w[:i] + c + w[i+1:]
                    if nw in words:
                        next_layer[nw].add(w)
                        if nw == end:
                            found = True
        for k, v in next_layer.items():
            parents[k] |= v
        layer = set(next_layer)

    res = []
    def dfs(node: str, path: list[str]) -> None:
        if node == begin:
            res.append([begin] + path[::-1])
            return
        for p in parents[node]:
            path.append(node)
            dfs(p, path)
            path.pop()
    if found:
        dfs(end, [])
    return res

Complexity: BFS O(N·L·26), DFS O(K·L) where K is the number of paths.

What reviewers grade:

• Must BFS for shortest length first; DFS-only explodes
• words -= layer per layer to prevent revisits
• Bidirectional BFS is even better, but layered BFS + visited is enough to pass

Classic 3: Insert / Delete / GetRandom O(1)

Implement a data structure supporting insert(val), remove(val), and getRandom() — all O(1).

Idea: HashMap (val → index) + dynamic array. Delete by swapping the target with the array tail and popping.

import random

class RandomizedSet:
    def __init__(self):
        self.arr: list[int] = []
        self.idx: dict[int, int] = {}

    def insert(self, val: int) -> bool:
        if val in self.idx:
            return False
        self.idx[val] = len(self.arr)
        self.arr.append(val)
        return True

    def remove(self, val: int) -> bool:
        if val not in self.idx:
            return False
        i = self.idx[val]
        last = self.arr[-1]
        self.arr[i] = last
        self.idx[last] = i
        self.arr.pop()
        del self.idx[val]
        return True

    def getRandom(self) -> int:
        return random.choice(self.arr)

Complexity: O(1) for every operation.

What reviewers grade:

• swap-and-pop is the key — arr.remove(val) is O(n) and fails
• Update self.idx[last] = i before popping, otherwise last's index breaks
• Test the corner where val == last (deleting the tail itself)

Behavioral round: Leadership Principles template

Amazon scores BQ rounds against 16 LPs. Five most-frequently probed for interns:

LP	Your story should answer
Customer Obsession	Who's the user? How did you collect feedback?
Ownership	Did you own a feature end-to-end?
Bias for Action	A decision under incomplete info — outcome?
Learn and Be Curious	Recent new tech learned and applied?
Are Right, A Lot	The hardest call you made — how?

Have 1-2 STAR stories per LP, each with a quantitative outcome (user count / perf / time saved).

OA → VO cadence (4-6 weeks)

W1     Application + resume screen
W2-3   OA1 + OA2 double gate, awaiting result
W3-4   Onsite invite, 1-2 weeks of prep
W5     Tech onsite (2-3 hrs)
W6     Decision + offer call

OA1 feedback can take 1-3 weeks; peak intern season may stretch to 4. Don't panic — apply elsewhere in parallel.

VO assist plug-in points for Amazon Intern

Amazon Intern's pain is "stable bank + LP scoring." Standard VO assist (VO interview assist (VO live support)) cadence:

1. Bank identification — invitation screenshot tells us OA1 vs OA2 pattern within 5 minutes
2. Three-classics drill — 1 hour of hand-coding each: LRU / Word Ladder II / Insert-Delete-GetRandom
3. Timed mock — 45 min × 3 onsite cadence simulation
4. Live cueing — backstage skeleton + LP keyword prompts during onsite
5. STAR story polishing — 1-2 stories pre-mapped to the 5 core LPs
6. Workstyle Survey calibration — neither gaming nor ignoring LP signals

FAQ

Q1: How long for Amazon SDE Intern OA results? A: Usually 1-3 weeks. Peak season can stretch to 4. After 4, email recruiter to follow up.

Q2: Do both OA1 problems need 100% AC to advance? A: Not always. One full AC + one partial 90%+ still has a path. Both under 50% is almost certainly a reject.

Q3: I have no AWS experience — am I cut? A: No. Interns don't need AWS, but a "deployed a side project on AWS" line earns small bonus points.

Q4: Do I need to memorize all 16 LPs for behavioral? A: All 16 is overkill. Have 1-2 STAR stories on the 5 core LPs (table above) and you'll cover ~80% of the prompts.

Q5: Intern → NG conversion rate? A: Amazon's intern-to-NG conversion is ~60-70% (above the industry average of 50%). Intern performance directly grades the NG offer.

Closing

Amazon SDE Intern doesn't need creativity bursts — it needs "classic problems done cleanly + LP stories told clearly + Workstyle answered honestly." That's the formula. If you're prepping the OA or VO, message WeChat Coding0201 with the JD and current stage screenshot. We'll scope the role line first, then plan VO assist / VO live support cadence.

---

Need real interview material? Add WeChat Coding0201 now to request access.

---

Contact

• WeChat: Coding0201
• Email: [email protected]
• Telegram: @OAVOProxy