LinkedIn Data Scientist Interview Questions

LinkedIn's data pipelines require streaming feature aggregation for real-time analytics to improve user engagement and provide timely insights. Design a system that aggregates features from user activities as they occur.Class Signature: class FeatureAggregator:
def __init__(self, time_window: int):
pass
def add(self, user_id: int, features: Dict[str, Any]) -> None:
pass
def get_aggregated_features(self, user_id: int) -> Dict[str, Any]:
passExample 1:
Input: aggregator = FeatureAggregator(60)
aggregator.add(1, {'likes': 2, 'comments': 3})
aggregator.add(1, {'likes': 1})
aggregator.get_aggregated_features(1)
Output: {'likes': 3, 'comments': 3}Example 2:
Input: aggregator.add(1, {'comments': 1})
aggregator.get_aggregated_features(1)
Output: {'likes': 3, 'comments': 4}Constraints:
- 1 <= time_window <= 600
- User IDs and feature keys are non-negative integers, and feature values are also integers.

LinkedIn's API serves a high volume of requests for data, necessitating an efficient caching mechanism to reduce latency and improve user experience. Implement an LRU (Least Recently Used) cache to store and retrieve API responses. Function Signature: class LRUCache:
def __init__(self, capacity: int):
pass
def get(self, key: int) -> int:
pass
def put(self, key: int, value: int) -> None:
passExample 1:
Input: lru = LRUCache(2)
lru.put(1, 1)
lru.put(2, 2)
lru.get(1)
Output: 1
Explanation: Returns 1, as it is the value for key 1. The cache is now: {1=1, 2=2}.Example 2:
Input: lru.put(3, 3)
lru.get(2)
Output: -1
Explanation: Returns -1, as key 2 was evicted when key 3 was added. The cache is now: {1=1, 3=3}.Constraints:
- 1 <= capacity <= 3000
- 0 <= key, value <= 10^4.

LinkedIn users are connected through various relationships, and understanding the shortest connection path between users can enhance user recommendations.
Given a graph representation of users and their connections as an adjacency list, implement Dijkstra's algorithm to find the shortest path from one user to another.Function Signature: def find_shortest_path(connections: Dict[int, List[Tuple[int, int]]], start: int, end: int) -> List[int]Example 1:
Input: {0: [(1, 1), (2, 4)], 1: [(2, 2)], 2: [(3, 1)], 3: []}, start=0, end=3
Output: [0, 1, 2, 3]
Explanation: The shortest path from user 0 to user 3 is 0 -> 1 -> 2 -> 3, with a total weight of 4.Example 2:
Input: {0: [(1, 5), (2, 1)], 1: [(2, 2), (3, 1)], 2: [(3, 4)], 3: []}, start=0, end=3
Output: [0, 1, 3]
Explanation: Path is from 0 to 1 to 3, with a weight of 6.Constraints:
- 1 <= len(connections) <= 1000
- Each connection weight is a positive integer.

LinkedIn's platform requires identifying the most engaged users over various time frames for enhanced user experience and targeted marketing strategies.
Given a list of user activity timestamps (in seconds) and a fixed time frame, write a function that returns the number of unique users who were active during that window.Function Signature: def count_active_users(timestamps: List[int], time_frame: int) -> intExample 1:
Input: [1, 2, 3, 4, 5, 6, 7], time_frame=3
Output: 5
Explanation: The unique users active between timestamps 1 and 3 are 1, 2, 3.Example 2:
Input: [1, 2, 2, 3, 5, 7, 9], time_frame=4
Output: 5
Explanation: The unique users between timestamps 2 and 5 are 1, 2, 3, 5.Constraints:
- 1 <= len(timestamps) <= 100000
- 0 <= timestamps[i] <= 10^9
- time_frame is a positive integer.