Most Popular Video Creator - Practice Coding Problems

🎥 Most Popular Video Creator

You're working as a data analyst for a video streaming platform similar to YouTube. Your task is to identify the most popular content creators based on their total view counts across all their videos.

Given three arrays:

creators[i] - the name of the creator who made the i-th video
ids[i] - the unique identifier of the i-th video
views[i] - the number of views the i-th video has received

Your Goal: Find the creator(s) with the highest total popularity (sum of all their video views) and identify their most popular video.

Special Rules:

If multiple creators tie for highest popularity, include all of them
If a creator has multiple videos with the same highest view count, choose the one with the lexicographically smallest video ID
Different videos can share the same ID (they're still considered separate videos)

Return a 2D array where each row contains [creator_name, most_popular_video_id] for each top creator.

Input & Output

example_1.py — Basic Case

$ Input: creators = ["alice","bob","alice","charlie"] ids = ["one","two","three","four"] views = [5,10,5,4]

› Output: [["alice","one"]]

💡 Note: Alice has total views of 5+5=10, Bob has 10 views, Charlie has 4 views. Alice has the highest total. Among Alice's videos, both have 5 views, but 'one' is lexicographically smaller than 'three'.

example_2.py — Multiple Winners

$ Input: creators = ["alice","alice","alice"] ids = ["a","b","c"] views = [1,2,2]

› Output: [["alice","b"]]

💡 Note: Alice is the only creator with total views of 5. Among her videos with max views (2), 'b' is lexicographically smaller than 'c'.

example_3.py — Tie Breaker

$ Input: creators = ["alice","bob","charlie"] ids = ["video1","video2","video3"] views = [10,10,10]

› Output: [["alice","video1"],["bob","video2"],["charlie","video3"]]

💡 Note: All creators have equal popularity (10 views each), so all are included in the result with their respective video IDs.

Visualization

Tap to expand

Understanding the Visualization

Initialize Tracking

Set up data structures to monitor creator performance metrics

Process Video Stream

As each video data arrives, update the creator's total views and check if it's their new best video

Update Leaderboard

Track the highest total popularity and identify leading creators

Generate Report

Compile final results showing top creators and their most successful videos

Key Takeaway

🎯 Key Insight: By processing the video stream once and maintaining running statistics, we can efficiently identify the most successful creators and their top-performing content in linear time.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through n videos, with constant time hash map operations

✓ Linear Growth

Space Complexity

O(k)

Where k is the number of unique creators, for storing creator statistics

✓ Linear Space

Constraints

n == creators.length == ids.length == views.length
1 ≤ n ≤ 10⁵
1 ≤ creators[i].length, ids[i].length ≤ 5
creators[i] and ids[i] consist of lowercase English letters only
0 ≤ views[i] ≤ 10⁵

Asked in

G Google 45 a Amazon 38 f Meta 32 N Netflix 28

The optimal solution uses a one-pass hash table approach with O(n) time complexity. We maintain two hash maps: one tracking each creator's total views and another tracking their best video. During a single iteration through the input, we update both statistics simultaneously while keeping track of the maximum popularity seen so far. Finally, we collect all creators with maximum popularity and return their best videos.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Passes)	O(n² × k)	O(k)	Calculate each creator's total views separately, then find maximum and best videos
One-Pass Hash Table (Optimal)	O(n)	O(k)	Build creator statistics and find winners in a single pass through the data

Brute Force (Multiple Passes) — Algorithm Steps

Find all unique creators by scanning the entire creators array
For each creator, scan all videos to calculate their total view count
Find the maximum popularity among all creators
For each creator with maximum popularity, scan all their videos to find the one with most views (lexicographically smallest ID for ties)

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Unique Creators

Scan entire array to identify all unique creator names

Calculate Totals

For each creator, scan all videos again to sum their total views

Find Maximum

Compare all creator totals to find the highest popularity

Find Best Videos

For each top creator, scan their videos again to find their most popular one

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char*** mostPopularCreator(char** creators, char** ids, int* views, int n, int* returnSize, int** returnColumnSizes) {
    // Implementation would be complex in C due to dynamic string handling
    // This is a simplified version showing the approach
    *returnSize = 0;
    return NULL;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × k)

Where n is number of videos and k is number of unique creators. We scan all videos for each creator multiple times.

⚠ Quadratic Growth

Space Complexity

O(k)

Only storing the list of unique creators and result array

✓ Linear Space

Constraints

n == creators.length == ids.length == views.length
1 ≤ n ≤ 10⁵
1 ≤ creators[i].length, ids[i].length ≤ 5
creators[i] and ids[i] consist of lowercase English letters only
0 ≤ views[i] ≤ 10⁵

95.0K Views

Medium Frequency

~15 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

🎥 Most Popular Video Creator

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Multiple Passes) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler