Apple Software Engineer Interview Questions

I would use binary search, but I would first identify which half of the array is properly sorted at each step. Once I know the sorted side, I can decide whether the target belongs there or in the other half. The reason I choose this approach is that it keeps the time complexity at O(log n). I would also mention edge cases like arrays with one element, no rotation, and the possibility of duplicates if the interviewer includes them. If duplicates are allowed, I would explain that the logic becomes a little more careful because the sorted side is not always obvious.

I would first think about the brute-force solution where I check every pair, but that is O(n^2). To optimize it, I would use a hash map to store the numbers I have seen so far and look up the complement of the current value as I scan the array. The reason I choose this approach is that it reduces the time complexity to O(n) and is easy to implement correctly. I would also mention edge cases like duplicate numbers and making sure I do not use the same element twice. If the interviewer wants all pairs instead of one pair, I would say the approach can be adjusted.

I would use recursion and return zero for a null node. For a real node, I would return one plus the maximum of the left and right subtree depths. The reason I choose this approach is that it is clean and directly matches the structure of the tree. The time complexity is O(n) because each node is visited once, and the space complexity is O(h) for the recursion stack. I would also mention that BFS is another option if I want to process the tree level by level.

I would avoid computing the height of the same subtree over and over again. Instead, I would use a recursive helper that returns both the height and whether the subtree is balanced. If either side is unbalanced or the height difference is more than one, I would mark the current subtree as unbalanced too. The reason I choose this approach is that it runs in O(n) time instead of O(n^2). I would also mention edge cases like an empty tree and a tree that is completely skewed to one side.

I would use one stack for incoming items and one for outgoing items. When I need to pop or peek and the outgoing stack is empty, I would move everything from the incoming stack to the outgoing one, which reverses the order and gives me FIFO behavior. The reason I choose this approach is that it is simple and gives amortized O(1) operations. Push is always O(1), and pop becomes O(1) amortized even though a transfer can cost O(n) occasionally. I would also mention edge cases like popping from an empty queue.