Analyze User Website Visit Pattern

The simplest correct translation of the definition: rebuild each user’s timeline in visit order, enumerate every triple of positions (i, j, k) with i < j < k, and tally how many distinct users produced each ordered triple. Group the tuples first (a plain dict), sort each user’s visits by timestamp (the pattern needs chronological order), and keep a per-user set so the same user cannot inflate a pattern’s score twice. Finally, pick the triple with the highest count, breaking ties lexicographically.

class Solution:
    def mostVisitedPattern(
        self, username: list[str], timestamp: list[int], website: list[str]
    ) -> list[str]:
        visits = {}
        for user, ts, site in zip(username, timestamp, website):
            visits.setdefault(user, []).append((ts, site))
        for user in visits:
            visits[user].sort()

        counter = {}
        for user in visits:
            sites = [site for _, site in visits[user]]
            m = len(sites)
            distinct = set()
            for i in range(m - 2):
                for j in range(i + 1, m - 1):
                    for k in range(j + 1, m):
                        distinct.add((sites[i], sites[j], sites[k]))
            for triple in distinct:
                counter[triple] = counter.get(triple, 0) + 1

        best = min(counter, key=lambda t: (-counter[t], t))
        return list(best)

Why it is O(U·L³): with U users and L the length of the longest user timeline, enumerating every i<j<k triple costs up to C(L,3) pairs per user, so the innermost loops run O(U·L³) times. The two other forces in the problem are handled by bookkeeping, not by the loops: timestamps vanish once each timeline is sorted, and the within-user set guarantees a user shows up only once per pattern. Space matches time in the worst case because the counter can hold every distinct triple (O(U·L³)).

The streamlined version of the same idea, organized as the standard “dict-of-users → dict-of-patterns” pipeline. Sort each user’s visits once, generate their distinct triples with a set, and increment a per-pattern user counter — then a single pass over the counter returns the largest-count pattern with the lexicographic tie-break baked into the key. There is no asymptotically faster general approach: in the worst case a solution must examine every triple of every user, so O(U·L³) is unavoidable; this version is optimal in the sense of being the tightest standard implementation of that bound.

from collections import defaultdict


class Solution:
    def mostVisitedPattern(
        self, username: list[str], timestamp: list[int], website: list[str]
    ) -> list[str]:
        visits = defaultdict(list)
        for user, ts, site in zip(username, timestamp, website):
            visits[user].append((ts, site))
        for user in visits:
            visits[user].sort()

        cnt = defaultdict(int)
        for user in visits:
            sites = [site for _, site in visits[user]]
            m = len(sites)
            combos = set()
            for i in range(m - 2):
                for j in range(i + 1, m - 1):
                    for k in range(j + 1, m):
                        combos.add((sites[i], sites[j], sites[k]))
            for c in combos:
                cnt[c] += 1

        return list(min(cnt, key=lambda t: (-cnt[t], t)))

Watch the pipeline run to completion on the file example: the per-user timelines are built first, then james’s four triples light up one at a time (reusing his duplicate home from different positions), and finally the scoreboard crowns home, about, career because joe and mary both realize it:

Why use a per-user set while still being optimal: the set is what keeps the score a true user-count. Without it, a user whose visits produce the same site triple from two different index combinations (e.g. a timeline like [a, a, b, b] yields (a, a, b) twice) would count that pattern twice — reporting a score no user actually merits. That single set() call is the difference between a correct answer and an overcount, and it does not change the asymptotic bound. The lexicographic tie-break falls out of key=lambda t: (-cnt[t], t): a smaller triple wins whenever two counts tie. Space is O(U·L³) in the worst case, equal to the number of distinct triples stored.