Meta Software Engineer Interview Questions

Before designing it, I would clarify whether the feed is purely chronological or ranked, because that changes pagination and caching. At a high level, I would use cursor-based pagination instead of offset-based pagination so the user gets stable results as new content arrives. I would store feed items in a way that supports fast lookups by user and timestamp, and I would make sure the API returns a cursor for the next page. The trade-off is that cursor-based pagination is a little more complex than simple offsets, but it scales much better and avoids duplicate or missing items when the underlying data changes. I would also consider caching the first few pages because that is where most traffic usually lands.

I would first think about the brute-force triple loop, but that is too slow. To optimize it, I would sort the array and then fix one element while using two pointers to search for the remaining two values. Sorting helps because it lets me move the pointers inward based on whether the current sum is too small or too large. The reason I choose this approach is that it reduces the time complexity to O(n^2), which is the standard efficient solution for this problem. I would also mention edge cases like duplicates, all-positive arrays, and arrays with fewer than three elements.

I would first think about how to represent the graph structure so I can reconstruct it later without losing edges or node identities. A practical approach is to assign each node a unique ID and store an adjacency list representation, along with any node values needed for reconstruction. During deserialization, I would rebuild the nodes first and then reconnect the edges based on those IDs. The reason I choose an ID-based adjacency format is that graphs can have cycles, so a tree-style recursive format is not enough. I would also mention that the time complexity is O(V + E) and that I need to be careful about shared nodes and disconnected components.

I would use recursion or BFS. With recursion, I would return zero for a null node and otherwise return one plus the maximum depth of the left and right subtrees. The reason I like this approach is that it is simple and directly reflects the structure of the tree. The time complexity is O(n) because every node is visited once, and the space complexity is O(h) for recursion, where h is the tree height. I would also mention that BFS is a good alternative if I want to measure depth level by level.

I would first clarify whether the typing indicator is for one-on-one chats, group chats, or both, because the fan-out changes a lot. At a high level, the client would send lightweight typing events over a persistent connection, and the server would forward those events to the relevant recipients with a short expiration window. I would not store typing state permanently because it is ephemeral and only useful for a few seconds. The trade-off is between freshness and backend load, so I would keep the protocol minimal and rate-limited. I would also handle disconnects and timeouts so the indicator disappears automatically if no new event arrives.