Pure Storage·Software Engineer·Onsite - Coding / Algorithms·Intermediate

IntermediatePrefer not to say

May 2026

Summary

Pure Storage SWE interview, coding round focused on data structure design. One question but it had enough layers to keep me busy for the whole session.

Questions Asked (1)

Design a data structure that supports insert, remove, and getRandom operations, each running in O(1) average time.

Algorithms & Data StructuresTechnical Trade-offs

Author's notes

I knew the hash map piece pretty quickly but then stared at getRandom for an embarrassingly long time.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the requirements: the data structure should support insert, remove, and getRandom in O(1) average time, and we can assume no duplicates. Then propose a hybrid approach using a dynamic array (or list) for O(1) random access and a hash map for O(1) insert/remove by mapping values to their indices. Explain how removal is handled by swapping the element with the last one and updating the hash map.

Pro tip: Mention that getRandom must be truly uniform, so using a hash map alone won't work because iterating over it is O(n). Also, discuss edge cases like removing the last element or when the data structure is empty.

1. Clarify requirements and assumptions

Confirm that all operations must be O(1) average time, that duplicates are not allowed (or discuss handling duplicates), and that getRandom should return each element with equal probability.

2. Choose the right data structures

Use a dynamic array (e.g., ArrayList in Java, list in Python) for O(1) random access and a hash map (dictionary) to store value-to-index mappings for O(1) lookups.

3. Implement insert operation

Append the new element to the array and add its index to the hash map. This is O(1) amortized time.

4. Implement remove operation

To remove a value, get its index from the hash map. Swap it with the last element in the array, update the hash map for the swapped element, then remove the last element from both the array and the hash map.

5. Implement getRandom operation

Generate a random index between 0 and array length - 1, and return the element at that index. This is O(1) time and ensures uniform randomness.

Key Points to Mention

Time complexity analysis: insert O(1) amortized, remove O(1) average, getRandom O(1).
Space complexity: O(n) for storing n elements.
Handling duplicates: either disallow or use a hash map of value to a set of indices, but then removal becomes more complex.
Edge cases: removing the last element, removing when only one element exists, and handling empty data structure.
Uniform randomness: using array index ensures each element has equal probability.
Comparison with alternative approaches: e.g., using only a hash map fails for getRandom because iteration is O(n).

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