Apple Backend Engineer Interview Questions

In a messaging system like iMessage, managing messages efficiently is essential for user experience. A simple messaging queue allows users to send and receive messages in an orderly manner, ensuring no message is lost.Implement a class MessageQueue with the following methods:
- def __init__(self): - Initializes the messaging queue.
- def send(self, message: str) -> None: - Sends a new message to the queue.
- def receive(self) -> str: - Receives the oldest message from the queue, returning it.
- def size(self) -> int: - Returns the current number of messages in the queue.Example 1:
Input: mq = MessageQueue() followed by mq.send('Hello')
Output: None
Explanation: The message is queued but no output is returned.Example 2:
Input: mq.receive() after the previous send
Output: 'Hello'
Explanation: The oldest message, 'Hello', is returned.Constraints:
- 1 <= message.length <= 100
- 1 <= number of messages <= 10^4

To ensure a reliable and fair experience for users, Apple’s App Store needs to manage its traffic effectively. A rate limiter can help maintain the maximum number of requests per user within a given timeframe.Implement a class RateLimiter that provides the following methods:
- def __init__(self, limit: int, time_window: int): - Initializes the rate limiter with a specified request limit and time window.
- def request(self, user_id: str) -> bool: - Determines if a request from user_id should be allowed based on current limits.
- def cleanup(self): - Cleans up expired requests from the records.Example 1:
Input: limiter = RateLimiter(5, 10) followed by limiter.request('user1')
Output: True
Explanation: The first request from user1 is accepted.Example 2:
Input: limiter.request('user1', 5) five times
Output: False
Explanation: After the fifth request, further requests are blocked.Constraints:
- 1 <= limit <= 100
- 1 <= time_window <= 60
- 1 <= Number of Requests <= 10^4

Apple's AirPods need an intelligent system to maintain an active list of connections based on user movements and proximity. An efficient algorithm can help track active devices using the Sliding Window technique.Given an array of connection times and an integer k, return the maximum number of active connections at any given time within the last k seconds.- def max_active_connections(times: List[int], k: int) -> int: returns the maximum number of connections.Example 1:
Input: times = [1, 2, 5, 6, 7], k = 3
Output: 3
Explanation: At time 5, there are 3 active connections (from 3 to 5).Example 2:
Input: times = [1, 2, 3, 4, 5], k = 2
Output: 2
Explanation: At times 4 and 5, the number of active connections within k=2 seconds is 2.Constraints:
- 1 <= len(times) <= 10^5
- 1 <= k <= 10^3

In Apple Maps, it’s essential to provide users with the shortest and fastest routes possible. Efficiently calculating these routes involves analyzing weighted graphs to identify optimal paths between locations.Write a function that implements Dijkstra's algorithm to find the shortest path from a source node to all other nodes in a weighted graph represented by an adjacency list.- def dijkstra(graph: Dict[int, List[Tuple[int, int]]], source: int) -> Dict[int, int]: returns a dictionary mapping each node to its shortest distance from the source.Example 1:
Input: graph = {0: [(1, 4), (2, 1)], 1: [(3, 1)], 2: [(1, 2), (3, 5)], 3: []}, source = 0
Output: {0: 0, 1: 3, 2: 1, 3: 4}
Explanation: The shortest distances from the source node 0 to all other nodes are calculated.Example 2:
Input: graph = {0: [(1, 2)], 1: [(2, 5)], 2: []}, source = 0
Output: {0: 0, 1: 2, 2: 7}
Explanation: The shortest paths are derived from the source node 0.Constraints:
- 1 <= len(graph) <= 10^5
- 0 <= source < len(graph)