Most Popular Video Creator

🎥 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"],["bob","two"]]

💡 Note: Alice has total views of 5+5=10, Bob has 10 views, Charlie has 4 views. Both Alice and Bob tie for highest total (10). Alice's best video is 'one' (both her videos have 5 views, 'one' < 'three' lexicographically). Bob's best video is 'two'.

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.

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⁵

Visualization

Tap to expand

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

✓ Brute Force (Multiple Passes)

⏱️ Time: O(n² × k) Space: O(k)

For each unique creator, iterate through all videos to calculate their total views. Then find the maximum popularity and iterate again to find each top creator's best video.

One-Pass Hash Table (Optimal)

⏱️ Time: O(n) Space: O(k)

Use hash tables to simultaneously track each creator's total views and their best video while iterating through the input arrays only once. This is the most efficient approach.

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>
#include <ctype.h>

static char creators_data[1000][101];
static char ids_data[1000][101];
static int views_data[1000];
static char result_creators[1000][101];
static char result_ids[1000][101];

typedef struct {
    char creator[101];
    int views;
} CreatorViews;

static CreatorViews creator_views[1000];

// Parse ["alice","bob","alice","charlie"] format
void parseStringArray(const char* str, char arr[][101], int* size) {
    *size = 0;
    const char* p = str;

    while (*p) {
        // Find opening quote
        if (*p == '"') {
            p++; // skip opening quote
            int i = 0;
            while (*p && *p != '"') {
                arr[*size][i++] = *p++;
            }
            arr[*size][i] = '\0';
            (*size)++;
            if (*p == '"') p++; // skip closing quote
        } else {
            p++;
        }
    }
}

// Parse [5,10,5,4] format
void parseIntArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;

    while (*p) {
        if (isdigit(*p) || (*p == '-' && isdigit(*(p + 1)))) {
            arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
        } else {
            p++;
        }
    }
}

int mostPopularCreator(char creators[][101], char ids[][101], int* views, int n, char result_creators[][101], char result_ids[][101]) {
    int creator_count = 0;

    for (int i = 0; i < n; i++) {
        char* creator = creators[i];
        int found = -1;

        for (int j = 0; j < creator_count; j++) {
            if (strcmp(creator_views[j].creator, creator) == 0) {
                found = j;
                break;
            }
        }

        if (found == -1) {
            strcpy(creator_views[creator_count].creator, creator);
            creator_views[creator_count].views = 0;
            found = creator_count;
            creator_count++;
        }

        creator_views[found].views += views[i];
    }

    // Find maximum popularity
    int max_views = creator_views[0].views;
    for (int i = 1; i < creator_count; i++) {
        if (creator_views[i].views > max_views) {
            max_views = creator_views[i].views;
        }
    }

    // Find top creators and their best videos
    int result_size = 0;

    for (int c = 0; c < creator_count; c++) {
        if (creator_views[c].views == max_views) {
            char* creator = creator_views[c].creator;
            int best_views = -1;
            char best_id[101] = "";
            int first = 1;

            for (int i = 0; i < n; i++) {
                if (strcmp(creators[i], creator) == 0) {
                    if (first) {
                        best_views = views[i];
                        strcpy(best_id, ids[i]);
                        first = 0;
                    } else if (views[i] > best_views) {
                        best_views = views[i];
                        strcpy(best_id, ids[i]);
                    } else if (views[i] == best_views && strcmp(ids[i], best_id) < 0) {
                        strcpy(best_id, ids[i]);
                    }
                }
            }

            strcpy(result_creators[result_size], creator);
            strcpy(result_ids[result_size], best_id);
            result_size++;
        }
    }

    return result_size;
}

int main() {
    char line1[10000], line2[10000], line3[10000];

    if (!fgets(line1, sizeof(line1), stdin)) return 1;
    if (!fgets(line2, sizeof(line2), stdin)) return 1;
    if (!fgets(line3, sizeof(line3), stdin)) return 1;

    line1[strcspn(line1, "\n")] = '\0';
    line2[strcspn(line2, "\n")] = '\0';
    line3[strcspn(line3, "\n")] = '\0';

    int n1, n2, n3;
    parseStringArray(line1, creators_data, &n1);
    parseStringArray(line2, ids_data, &n2);
    parseIntArray(line3, views_data, &n3);

    int result_size = mostPopularCreator(creators_data, ids_data, views_data, n1, result_creators, result_ids);

    printf("[");
    for (int i = 0; i < result_size; i++) {
        if (i > 0) printf(",");
        printf("['%s','%s']", result_creators[i], result_ids[i]);
    }
    printf("]\n");

    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.

✓ Linear Growth

Space Complexity

O(k)

Only storing the list of unique creators and result array

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Multiple Passes) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler