Analyze User Website Visit Pattern - Practice Coding Problems

Analyze User Website Visit Pattern - Problem

Imagine you're a data analyst at a major tech company, tasked with understanding user behavior patterns on your platform. You have access to user browsing logs and need to identify the most popular 3-website sequences that users follow.

Given three arrays of equal length:

username - Array of usernames
website - Array of websites visited
timestamp - Array of visit timestamps

Each triplet [username[i], website[i], timestamp[i]] represents a single visit event.

Your task is to find the most popular 3-website pattern - a sequence of exactly 3 websites that users visit in chronological order (not necessarily consecutively). The pattern's score is the number of unique users who visited all 3 websites in that exact order.

Goal: Return the pattern with the highest score. If there's a tie, return the lexicographically smallest pattern.

Example: If pattern ["home", "about", "career"] has score 5, it means 5 different users visited "home", then later "about", then later "career" (with possible other visits in between).

Input & Output

example_1.py — Basic Pattern Analysis

$ Input: username = ["joe","joe","joe","james","james","james","james","mary","mary","mary"] timestamp = [1,2,3,4,5,6,7,8,9,10] website = ["home","about","career","home","cart","maps","home","home","about","career"]

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

💡 Note: Three users (joe, mary, and implicitly others) followed the pattern [home→about→career]. User joe visited: home(1)→about(2)→career(3). User mary visited: home(8)→about(9)→career(10). This pattern appears more frequently than any other 3-website sequence.

example_2.py — Lexicographic Ordering

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

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

💡 Note: User ua visits: a(1)→b(2)→a(3), generating pattern [a,b,a]. User ub visits: a(4)→b(5)→c(6), generating pattern [a,b,c]. Both patterns have count 1, but [a,b,a] is lexicographically smaller than [a,b,c], so we return [a,b,a].

example_3.py — Multiple Valid Patterns Per User

$ Input: username = ["alice","alice","alice","alice"] timestamp = [1,2,3,4] website = ["home","shop","blog","news"]

› Output: ["blog","home","news"] or similar

💡 Note: Single user alice generates multiple patterns: [home,shop,blog], [home,shop,news], [home,blog,news], [shop,blog,news]. Each has count 1. The lexicographically smallest among these is returned. Note: this depends on the actual lexicographic comparison of all generated patterns.

Visualization

Tap to expand

Understanding the Visualization

Collect Raw Data

Gather all visit logs: user, timestamp, website

Sort & Group

Sort by time, group visits per user to maintain chronological order

Generate Patterns

For each user, create all possible 3-website combinations

Count & Rank

Count pattern frequencies across all users, select winner

Key Takeaway

🎯 Key Insight: Efficient pattern analysis requires careful ordering and deduplication - group by user first, then systematically generate combinations while avoiding double-counting patterns per user.

Time & Space Complexity

Time Complexity

⏱️

O(N log N + N × V³)

N log N for sorting visits, then N users × V³ combinations per user

⚡ Linearithmic

Space Complexity

O(N × V + P)

N×V for storing grouped visits, P for pattern frequency map

✓ Linear Space

Constraints

3 ≤ username.length ≤ 50
1 ≤ username[i].length ≤ 10
timestamp.length == username.length
1 ≤ timestamp[i] ≤ 10⁹
website.length == username.length
1 ≤ website[i].length ≤ 10
username[i] and website[i] consist of lowercase English letters
It is guaranteed that there is at least one user who visited at least 3 websites
All the tuples [username[i], timestamp[i], website[i]] are unique

Asked in

A Amazon 45 G Google 38 f Meta 32 ⊞ Microsoft 25 Apple 18

The optimal approach uses a two-pass hash table strategy: first group all visits by user and sort chronologically, then generate all valid 3-website combinations per user while avoiding duplicates with sets. The pattern with highest frequency (lexicographically smallest if tied) wins. Time complexity: O(N log N + Σ(Vi³)) where Vi is visits per user.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table (Optimal)	O(N log N + N × V³)	O(N × V + P)	Group visits by user first, then efficiently generate all valid patterns
Brute Force (Triple Nested Loops)	O(N * V³)	O(N * V + P)	Check every possible triplet of visits for each user

Two-Pass Hash Table (Optimal) — Algorithm Steps

First pass: Group all visits by username into a hash table
Sort each user's visits by timestamp to maintain chronological order
Second pass: For each user, generate all valid 3-combinations of websites
Use a set to avoid counting duplicate patterns per user
Count pattern frequencies across all users
Return the pattern with highest count (lexicographically smallest if tied)

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort & Group

Sort all visits by timestamp, group by user

Generate Patterns

For each user, create all 3-combinations

Deduplicate

Use set to avoid duplicate patterns per user

Count & Select

Count across users, select best pattern

Code -

solution.c — C

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

#define MAX_USERS 1000
#define MAX_VISITS 1000
#define MAX_PATTERNS 10000
#define MAX_LEN 50

typedef struct {
    int timestamp;
    int index;
} Visit;

typedef struct {
    char pattern[150];  // "site1,site2,site3"
    int count;
} PatternCount;

int compare_visits(const void *a, const void *b) {
    return ((Visit*)a)->timestamp - ((Visit*)b)->timestamp;
}

int compare_patterns(const void *a, const void *b) {
    PatternCount *p1 = (PatternCount*)a, *p2 = (PatternCount*)b;
    if (p1->count != p2->count) return p2->count - p1->count;
    return strcmp(p1->pattern, p2->pattern);
}

char** mostVisitedPattern(char** username, int* timestamp, char** website, int n, int* returnSize) {
    // First pass: Sort visits by timestamp
    Visit visits[n];
    for (int i = 0; i < n; i++) {
        visits[i].timestamp = timestamp[i];
        visits[i].index = i;
    }
    qsort(visits, n, sizeof(Visit), compare_visits);
    
    // Group visits by user
    char users[MAX_USERS][MAX_LEN];
    char userSites[MAX_USERS][MAX_VISITS][MAX_LEN];
    int userCounts[MAX_USERS] = {0};
    int userIndex[MAX_USERS];
    int numUsers = 0;
    
    for (int i = 0; i < n; i++) {
        int idx = visits[i].index;
        char* user = username[idx];
        char* site = website[idx];
        
        // Find or create user
        int uIdx = -1;
        for (int j = 0; j < numUsers; j++) {
            if (strcmp(users[j], user) == 0) {
                uIdx = j;
                break;
            }
        }
        if (uIdx == -1) {
            strcpy(users[numUsers], user);
            uIdx = numUsers++;
        }
        
        strcpy(userSites[uIdx][userCounts[uIdx]], site);
        userCounts[uIdx]++;
    }
    
    // Second pass: Generate patterns and count frequencies
    PatternCount patterns[MAX_PATTERNS];
    int numPatterns = 0;
    
    for (int u = 0; u < numUsers; u++) {
        if (userCounts[u] < 3) continue;
        
        // Generate all 3-combinations for this user
        char userPatterns[1000][150];
        int userPatternCount = 0;
        
        for (int i = 0; i < userCounts[u]; i++) {
            for (int j = i + 1; j < userCounts[u]; j++) {
                for (int k = j + 1; k < userCounts[u]; k++) {
                    sprintf(userPatterns[userPatternCount], "%s,%s,%s",
                           userSites[u][i], userSites[u][j], userSites[u][k]);
                    userPatternCount++;
                }
            }
        }
        
        // Remove duplicates and count patterns
        for (int p = 0; p < userPatternCount; p++) {
            // Check if this pattern already exists
            int found = -1;
            for (int q = 0; q < numPatterns; q++) {
                if (strcmp(patterns[q].pattern, userPatterns[p]) == 0) {
                    found = q;
                    break;
                }
            }
            
            if (found == -1) {
                strcpy(patterns[numPatterns].pattern, userPatterns[p]);
                patterns[numPatterns].count = 1;
                numPatterns++;
            } else {
                // Check if we already counted this pattern for this user
                int duplicate = 0;
                for (int q = p - 1; q >= 0; q--) {
                    if (strcmp(userPatterns[p], userPatterns[q]) == 0) {
                        duplicate = 1;
                        break;
                    }
                }
                if (!duplicate) {
                    patterns[found].count++;
                }
            }
        }
    }
    
    // Find the best pattern
    qsort(patterns, numPatterns, sizeof(PatternCount), compare_patterns);
    
    char** result = (char**)malloc(3 * sizeof(char*));
    char* token = strtok(patterns[0].pattern, ",");
    for (int i = 0; i < 3; i++) {
        result[i] = (char*)malloc(MAX_LEN * sizeof(char));
        strcpy(result[i], token);
        token = strtok(NULL, ",");
    }
    
    *returnSize = 3;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(N log N + N × V³)

N log N for sorting visits, then N users × V³ combinations per user

⚡ Linearithmic

Space Complexity

O(N × V + P)

N×V for storing grouped visits, P for pattern frequency map

✓ Linear Space

Constraints

3 ≤ username.length ≤ 50
1 ≤ username[i].length ≤ 10
timestamp.length == username.length
1 ≤ timestamp[i] ≤ 10⁹
website.length == username.length
1 ≤ website[i].length ≤ 10
username[i] and website[i] consist of lowercase English letters
It is guaranteed that there is at least one user who visited at least 3 websites
All the tuples [username[i], timestamp[i], website[i]] are unique

24.8K Views

High 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler