LinkedIn Mobile Engineer Interview Questions

LinkedIn's mobile platform requires efficient caching to enhance its API responses speed and reduce load on servers. Create an LRU (Least Recently Used) cache that resolves HTTP requests.- Function Signature: def LRUCache(capacity: int) -> None: - Initialize LRU cache system.
- Method 1: def get(key: str) -> Union[int, None]: - Return the value of the key if present, else return None.
- Method 2: def put(key: str, value: int) -> None: - Update or add the value if the key is not already present. If the cache reaches its capacity, it should invalidate the least recently used item.Example 1:
Input: cache = LRUCache(2)
cache.put(1,1)
cache.put(2,2)
cache.get(1)
Output: 1
Explanation: Returns the value for key 1.Example 2:
Input: cache.put(3,3)
cache.get(2)
Output: None
Explanation: Returns None since key 2 was evicted to make space.Constraints:
- 1 <= capacity <= 1000
- 0 <= key <= 10^5
- 0 <= value <= 10^5

LinkedIn users need to manage their messages even in low connectivity scenarios. Your job is to efficiently synchronize a user's messages when the connection is restored.
Given a list of messages, each with an associated timestamp, and a window_size, implement a function to retrieve messages that fall within that time window.- Function Signature: def sync_messages(messages: List[Tuple[str, int]], window_size: int) -> List[str]: - Return a list of messages within the timeframe of window_size.Example 1:
Input: messages = [('msg1', 1), ('msg2', 2), ('msg3', 5)], window_size = 3
Output: ['msg2', 'msg3']
Explanation: msg2 and msg3 are within a 3 second window of the last message.Example 2:
Input: messages = [('msg1', 1), ('msg2', 10), ('msg3', 15)], window_size = 5
Output: []
Explanation: No messages fall within the 5 seconds range.Constraints:
- 1 <= len(messages) <= 10^6
- 0 <= timestamp <= 10^9

As users may often face connectivity issues, LinkedIn wants to ensure users can still interact with their content offline and have changes synchronized when connectivity resumes.- Method 1: def save_post(user_id: str, post_content: str) -> None: - Save a new post; if offline, queue for syncing.
- Method 2: def retrieve_posts(user_id: str) -> List[Tuple[str, str]]: - Retrieve posts for a user with a flag showing online/offline status.
- Method 3: def sync_changes(user_id: str) -> None: - Sync any offline changes with the backend server.Constraints:
- The sync engine should handle conflicts gracefully when multiple changes occur for the same content.
- Users' actions should remain responsive while offline.Example 1:
Input: save_post('user123', 'My first post!')
Output: None
Explanation: Saves the post, queuing it if the user is offline.Example 2:
Input: sync_changes('user123')
Output: None
Explanation: Begins trying to sync changes made while offline.

As part of enhancing user engagement, LinkedIn wants to build a Push Notification Manager to handle various user notifications efficiently; this will integrate with real-time updates and user preferences.- Method 1: def send_notification(user_id: str, title: str, message: str) -> None: - Sends a notification to the specified user.
- Method 2: def schedule_notification(user_id: str, title: str, message: str, schedule_time: datetime) -> None: - Schedule a notification for a specific time.
- Method 3: def get_notifications(user_id: str) -> List[Tuple[str, str, datetime]]: - Retrieve all notifications for a user in chronological order.Constraints:
- All notifications should be pushed in real-time to users.
- Users should have an option to filter notifications by type.
- It should efficiently handle high traffic scenarios where multiple notifications may be sent simultaneously.Example 1:
Input: send_notification('user123', 'Connection Request', 'User456 wants to connect')
Output: None
Explanation: Sends a connection request notification to the user.Example 2:
Input: get_notifications('user123')
Output: [('Connection Request', 'User456 wants to connect', datetime.now())]
Explanation: Returns a list of notifications for user123.