Amazon Software Engineer Interview Questions

I would start with the brute-force idea of storing every visited node in a set and checking whether I see the same node again. That works, but it uses extra memory, so to optimize it I would use Floyd's cycle detection algorithm with two pointers, one moving slowly and one moving fast. If the list has a cycle, the fast pointer will eventually meet the slow pointer inside the loop. The reason I choose this approach is that it gives O(n) time and O(1) extra space, which is ideal for interview constraints. I would also mention edge cases like an empty list, a single-node list, and a single node pointing to itself. If the interviewer asks for the cycle entry point, I would explain the second phase where I reset one pointer to head and move both one step at a time until they meet.

I would first think about the brute-force idea of comparing every interval with every other interval, but that quickly becomes too expensive. To optimize it, I would sort the intervals by start time and then make one linear pass while keeping track of the current merged interval. If the next interval overlaps, I extend the end boundary; otherwise, I push the current interval and start a new one. The reason I choose sorting is that overlap becomes easy to reason about once the intervals are in order. That gives me O(n log n) time because of the sort and O(n) space if I store the output list. I would also mention edge cases like touching intervals, nested intervals, and already sorted input.

I would first think about a simple brute-force version using a list, where I scan to find keys and move recently used items to the front, but that would make get and put O(n). To optimize it, I would use a hash map for O(1) key lookup and a doubly linked list to maintain recency order. Every time I access a key, I would move its node to the front, and when capacity is exceeded I would evict from the tail because that is the least recently used item. The reason I choose a doubly linked list is that removal and insertion are both O(1) when I already have the node pointer. The overall operations are O(1) time and O(capacity) space. I would also mention edge cases like capacity one, overwriting an existing key, and repeated access to the same item.

I would first think about counting frequencies and then sorting all unique elements by frequency, but that would cost more than necessary. To optimize it, I would build a frequency map and then use a min-heap of size K so I only keep the K most frequent items as I scan the map. That gives me O(n log k) time rather than sorting everything, which is better when K is much smaller than the total number of unique values. The space is O(n) for the frequency map and O(k) for the heap. I would also mention the bucket-sort approach if the interviewer wants a linear-time alternative.

I would first think about whether I can simulate FIFO behavior with two LIFO structures. The standard approach is to use one stack for incoming pushes and another for outgoing pops; when the pop stack is empty, I transfer everything from the push stack to reverse the order. That way, each element is moved only a limited number of times, so the amortized cost is O(1) per operation. I would explain that push is always O(1), and pop is amortized O(1), even though a transfer can temporarily take O(n). I would also mention edge cases like popping from an empty queue and interleaving many push and pop operations.