Analyze User Website Visit Pattern

Analyze User Website Visit Pattern - Problem

You are given three arrays username, website, and timestamp, all of the same length. The tuple [username[i], website[i], timestamp[i]] indicates that user username[i] visited website website[i] at time timestamp[i].

A pattern is a list of three websites (not necessarily distinct). The score of a pattern is the number of users that visited all websites in the pattern in the same order they appeared in the pattern (chronologically).

Return the pattern with the largest score. If there are multiple patterns with the same largest score, return the lexicographically smallest pattern.

Input & Output

Example 1 — Multiple Users Same Pattern

$ Input: username = ["joe","joe","joe","james","james","james"], website = ["home","about","career","home","about","career"], timestamp = [1,2,3,4,5,6]

› Output: ["home","about","career"]

💡 Note: Both users 'joe' and 'james' visited home→about→career in chronological order, giving this pattern a score of 2, which is the maximum possible.

Example 2 — Lexicographic Tie Breaking

$ Input: username = ["ua","ua","ua","ub","ub","ub"], website = ["a","b","a","a","b","c"], timestamp = [1,2,3,4,5,6]

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

💡 Note: Two patterns have score 1: ["a","b","a"] and ["a","b","c"]. We return the lexicographically smaller one.

Example 3 — Same User Multiple Patterns

$ Input: username = ["u1","u1","u1","u1"], website = ["a","b","c","d"], timestamp = [1,2,3,4]

› Output: ["a","b","c"]

💡 Note: User 'u1' generates multiple 3-website patterns: ["a","b","c"], ["a","b","d"], ["a","c","d"], ["b","c","d"]. All have score 1, so we return the lexicographically smallest.

Constraints

3 ≤ username.length ≤ 50
1 ≤ username[i].length ≤ 10
1 ≤ website[i].length ≤ 10
1 ≤ timestamp[i] ≤ 10⁹
All tuples [username[i], website[i], timestamp[i]] are unique

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 f Facebook 8 M Microsoft 6

The key insight is to group visits by user first, then generate all possible 3-website subsequences while preserving chronological order. Best approach uses hash map to count pattern frequencies efficiently. Time: O(n³), Space: O(n²)

Common Approaches

✓ Brute Force - Generate All Patterns

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

For each user, sort their visits by timestamp, then check all possible 3-website subsequences. Count frequency of each pattern across all users.

Optimized Pattern Generation

⏱️ Time: O(n³) Space: O(n²)

First group all visits by username and sort by timestamp. Then for each user with at least 3 visits, generate all possible 3-website subsequences and count pattern frequencies using hash map.

Brute Force - Generate All Patterns — Algorithm Steps

Step 1: Group visits by username and sort by timestamp
Step 2: For each user, generate all possible 3-website combinations
Step 3: Count pattern frequencies and find maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Group by User

Organize visits by username and sort by timestamp

Generate Patterns

For each user, create all possible 3-website combinations

Count & Select

Count pattern frequencies and select lexicographically smallest maximum

Code -

solution.c — C

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

#define MAX_USERS 1000
#define MAX_VISITS 10000
#define MAX_PATTERNS 100000
#define MAX_STR_LEN 100

static char usernames[MAX_VISITS][MAX_STR_LEN];
static char websites[MAX_VISITS][MAX_STR_LEN];
static int timestamps[MAX_VISITS];
static char patterns[MAX_PATTERNS][3][MAX_STR_LEN];
static int pattern_counts[MAX_PATTERNS];
static int user_visits[MAX_USERS][MAX_VISITS];
static int user_visit_counts[MAX_USERS];
static char unique_users[MAX_USERS][MAX_STR_LEN];

int compare_visits(const void *a, const void *b) {
    int idx_a = *(int*)a;
    int idx_b = *(int*)b;
    return timestamps[idx_a] - timestamps[idx_b];
}

int compare_patterns(const void *a, const void *b) {
    int idx_a = *(int*)a;
    int idx_b = *(int*)b;
    
    // First compare by count (descending)
    if (pattern_counts[idx_a] != pattern_counts[idx_b]) {
        return pattern_counts[idx_b] - pattern_counts[idx_a];
    }
    
    // Then lexicographically
    for (int i = 0; i < 3; i++) {
        int cmp = strcmp(patterns[idx_a][i], patterns[idx_b][i]);
        if (cmp != 0) return cmp;
    }
    return 0;
}

int find_pattern(char p1[], char p2[], char p3[], int num_patterns) {
    for (int i = 0; i < num_patterns; i++) {
        if (strcmp(patterns[i][0], p1) == 0 && 
            strcmp(patterns[i][1], p2) == 0 && 
            strcmp(patterns[i][2], p3) == 0) {
            return i;
        }
    }
    return -1;
}

char* parse_string(char* input, int* pos) {
    static char result[MAX_STR_LEN];
    while (input[*pos] != '"') (*pos)++; // find opening quote
    (*pos)++; // skip opening quote
    int start = *pos;
    while (input[*pos] != '"') (*pos)++; // find closing quote
    int len = *pos - start;
    strncpy(result, input + start, len);
    result[len] = '\0';
    (*pos)++; // skip closing quote
    return result;
}

int parse_number(char* input, int* pos) {
    while (input[*pos] < '0' || input[*pos] > '9') (*pos)++; // find digit
    int num = 0;
    while (input[*pos] >= '0' && input[*pos] <= '9') {
        num = num * 10 + (input[*pos] - '0');
        (*pos)++;
    }
    return num;
}

int main() {
    char line[10000];
    int n = 0;
    
    // Parse usernames
    fgets(line, sizeof(line), stdin);
    int pos = 0;
    while (line[pos] && line[pos] != '\n') {
        if (line[pos] == '"') {
            char* username = parse_string(line, &pos);
            strcpy(usernames[n], username);
            n++;
        } else {
            pos++;
        }
    }
    
    // Parse websites
    fgets(line, sizeof(line), stdin);
    pos = 0;
    int web_count = 0;
    while (line[pos] && line[pos] != '\n') {
        if (line[pos] == '"') {
            char* website = parse_string(line, &pos);
            strcpy(websites[web_count], website);
            web_count++;
        } else {
            pos++;
        }
    }
    
    // Parse timestamps
    fgets(line, sizeof(line), stdin);
    pos = 0;
    int ts_count = 0;
    while (line[pos] && line[pos] != '\n') {
        if (line[pos] >= '0' && line[pos] <= '9') {
            timestamps[ts_count] = parse_number(line, &pos);
            ts_count++;
        } else {
            pos++;
        }
    }
    
    // Group by users
    int num_users = 0;
    for (int i = 0; i < n; i++) {
        int user_idx = -1;
        for (int j = 0; j < num_users; j++) {
            if (strcmp(unique_users[j], usernames[i]) == 0) {
                user_idx = j;
                break;
            }
        }
        if (user_idx == -1) {
            user_idx = num_users;
            strcpy(unique_users[num_users], usernames[i]);
            user_visit_counts[num_users] = 0;
            num_users++;
        }
        user_visits[user_idx][user_visit_counts[user_idx]] = i;
        user_visit_counts[user_idx]++;
    }
    
    // Sort visits for each user by timestamp
    for (int i = 0; i < num_users; i++) {
        qsort(user_visits[i], user_visit_counts[i], sizeof(int), compare_visits);
    }
    
    // Generate patterns
    int num_patterns = 0;
    for (int u = 0; u < num_users; u++) {
        if (user_visit_counts[u] < 3) continue;
        
        for (int i = 0; i < user_visit_counts[u]; i++) {
            for (int j = i + 1; j < user_visit_counts[u]; j++) {
                for (int k = j + 1; k < user_visit_counts[u]; k++) {
                    int vi = user_visits[u][i];
                    int vj = user_visits[u][j];
                    int vk = user_visits[u][k];
                    
                    int pattern_idx = find_pattern(websites[vi], websites[vj], websites[vk], num_patterns);
                    if (pattern_idx == -1) {
                        strcpy(patterns[num_patterns][0], websites[vi]);
                        strcpy(patterns[num_patterns][1], websites[vj]);
                        strcpy(patterns[num_patterns][2], websites[vk]);
                        pattern_counts[num_patterns] = 1;
                        num_patterns++;
                    } else {
                        pattern_counts[pattern_idx]++;
                    }
                }
            }
        }
    }
    
    // Find best pattern
    if (num_patterns > 0) {
        int indices[MAX_PATTERNS];
        for (int i = 0; i < num_patterns; i++) indices[i] = i;
        qsort(indices, num_patterns, sizeof(int), compare_patterns);
        
        printf("[\"%s\",\"%s\",\"%s\"]\n", 
               patterns[indices[0]][0], 
               patterns[indices[0]][1], 
               patterns[indices[0]][2]);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each user with k visits, we generate O(k³) patterns, worst case O(n³) total

⚠ Quadratic Growth

Space Complexity

O(n)

Hash map to store pattern frequencies and user visit lists

⚠ Quadratic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Generate All Patterns — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler