Netflix Data Scientist Interview Questions

Netflix requires a robust component to aggregate viewer metrics for real-time analysis, allowing teams to make data-driven decisions during live events. Create a class that accumulates metrics and provides statistical insights on viewer engagement.- Method Signature: class StreamingFeatureAggregator:
- def add_view(view_time: float): — Add a new viewer's view time.
- def get_average(self) -> float: — Get the current average view time.
- def get_median(self) -> float: — Get the current median view time.
- def get_total(self) -> float: — Get the total accumulated view time.Example 1:
Initialize an aggregator and add several view times, then retrieve statistics.
Example 2:
Handle concurrent view updates efficiently to ensure accuracy.Constraints:
- The number of view times can reach up to 1 million, with each view time being a positive float.

As Netflix plans out its content strategy, we need to analyze viewership data represented in a tree-structured format. Each node represents a show, with children representing episodes. We want to determine the average viewership for a given show and all its episodes combined.Problem statement: Given a tree node with the properties show_id, viewership, and children (representing episodes), implement a class method that calculates the average viewership for the show and its episodes combined.- Method Signature: def average_viewership(root: TreeNode) -> float: — returns the average viewership.Example 1:
Input: root = TreeNode(1, 100, [TreeNode(2, 50), TreeNode(3, 150)])
Output: 100.0
Explanation: Average is (100 + 50 + 150) / 3 = 100.0Example 2:
Input: root = TreeNode(1, 200, [TreeNode(4, 100)])
Output: 150.0
Explanation: Average is (200 + 100) / 2 = 150.0Constraints:
- Each node represents 1 ≤ show_id ≤ 10^6.
- The number of nodes in the tree can be between 1 and 1000.

Netflix needs an efficient SQL query to derive average movie ratings from a large dataset spanning various genres for personalized recommendations. This should support querying by specific genres and timeframes.Problem statement: Given a movies table with id, title, rating, and genre, write a SQL query to return the average rating for each genre in a specified from_date and to_date range.Example 1:
Input: from_date = '2022-01-01', to_date = '2022-12-31'
Output: genre | average_rating
Action | 8.5
Comedy | 7.7Example 2:
Input: from_date = '2021-05-01', to_date = '2021-10-01'
Output: genre | average_rating
Drama | 8.0
Documentary | 7.0Constraints:
- Movie records are relevant for the last 5 years.
- Each movie belongs to at least one genre.

Netflix needs an efficient algorithm to optimize recommendations by analyzing user watch times across multiple shows. The goal is to find the longest sequence of shows that users have watched in a single binge-watching session with a view time >= k.Problem statement: Given an integer array viewTimes, representing the view time of each show watched in order, and an integer k, return the length of the longest subarray where the sum of the view times is at least k. Utilize a sliding window approach to achieve optimal performance.- Method Signature: def longest_binge_watch(viewTimes: List[int], k: int) -> int: — returns the length of the longest subarray.Example 1:
Input: viewTimes = [1, 2, 3, 4, 5], k = 9
Output: 3
Explanation: The longest sequence with a total view time >= 9 is [3, 4, 5].Example 2:
Input: viewTimes = [2, 1, 5, 2, 3, 2], k = 7
Output: 5
Explanation: The longest sequence with a total view time >= 7 is [1, 5, 2, 3].Constraints:
- 1 <= viewTimes.length <= 10^5
- 1 <= viewTimes[i] <= 10^4
- 1 <= k <= 10^6