Amazon·Software Engineer·Technical Phone Screen·Intermediate

Intermediate

May 2026

Summary

Amazon SWE interview with an OOD problem centered on playing cards. Pretty focused session, just the one design problem but it had enough moving parts to keep you busy.

Questions Asked (1)

Design a standard deck of playing cards and implement two in-place operations on it: a shuffle function that randomizes an arbitrary deck, and a sort function that orders cards by suit (Clubs, Diamonds, Hearts, Spades) and then by rank (Ace through King).

Algorithms & Data StructuresSystem DesignTechnical Trade-offs

Author's notes

The shuffle part felt straightforward, Fisher-Yates came to mind pretty fast.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by defining a clear data model for a card and deck, then discuss the constraints of in-place operations. For shuffle, implement Fisher-Yates; for sort, choose a comparison-based sort (e.g., quicksort) with a custom comparator, or counting sort given the small fixed domain. Analyze trade-offs and edge cases.

Pro tip: Mention that Fisher-Yates is unbiased and O(n), and that sorting can be O(n) with counting sort due to the small fixed number of suits and ranks. This shows you consider optimal solutions and domain-specific optimizations.

1. Clarify requirements and constraints

Confirm that operations must be in-place (O(1) extra space) and that the deck is an array of cards. Ask about expected time complexity and whether the deck size is fixed (52 cards).

2. Design the data model

Define a Card with suit and rank (e.g., enums or integers). Represent the deck as an array of 52 cards. Explain how suits and ranks map to comparable values.

3. Implement in-place shuffle

Use the Fisher-Yates algorithm: iterate from the last index down to 1, swap the current card with a randomly chosen card from the remaining unshuffled portion. This guarantees a uniform random permutation in O(n) time and O(1) space.

4. Implement in-place sort

Choose a sorting algorithm that works in-place. Options: quicksort (average O(n log n), O(log n) stack space) with a custom comparator, or counting sort (O(n) time, O(1) space) since there are only 52 distinct cards. Discuss trade-offs.

5. Analyze and test

Analyze time and space complexity, and discuss edge cases (e.g., empty deck, already sorted). Mention testing strategies like verifying shuffle randomness and sort stability (if applicable).

Key Points to Mention

Fisher-Yates shuffle for unbiased randomization in O(n) time and O(1) space.
In-place sorting options: quicksort with custom comparator or counting sort due to small fixed domain.
Time and space complexity analysis for both operations.
Handling edge cases: empty deck, single card, already sorted deck.
Trade-offs between comparison-based and non-comparison sorts (e.g., counting sort).
Ensuring the shuffle is uniform and the sort is correct according to suit and rank order.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.