Analyze User Website Visit Pattern

You're given three arrays of the same length describing a visit log: username[i] visited website[i] at time timestamp[i]. The rows are not sorted by time.

A pattern is an ordered list of three websites, like ["home", "shop", "cart"]. The websites don't have to be different. A user follows a pattern if, looking at that user's visits in time order, they visited the first website, then later the second, then later the third. The three visits don't have to be back to back; other visits can happen in between.

The score of a pattern is the number of distinct users who follow it. A user who follows a pattern in several ways still adds only 1.

Return the pattern with the highest score. If several patterns tie, return the lexicographically smallest one: compare the first websites as strings, then the second, then the third. At least one user has three or more visits, so an answer always exists.

Break it into three steps you already know:

1. Order and group. Sort the rows by timestamp, then build each user's list of websites in time order.
2. Enumerate. For each user, every choice of indices i < j < k in their list gives a pattern they follow. Put these into a set first, so a user who follows the same pattern several ways contributes it once.
3. Count and pick. Add 1 to a global counter for each pattern in the user's set. At the end, take the highest count, breaking ties by the smallest pattern.

The set per user is the detail that makes or breaks the problem. Without it, one user who loops through the same pages repeatedly can outvote several real users.

def most_visited_pattern(username: list[str], timestamp: list[int], website: list[str]) -> list[str]:
    visits = defaultdict(list)  # user -> websites in time order
    for _, user, site in sorted(zip(timestamp, username, website)):
        visits[user].append(site)

    count = Counter()
    for sites in visits.values():
        count.update(set(itertools.combinations(sites, 3)))

    best = max(count.values())
    return list(min(p for p, c in count.items() if c == best))

function mostVisitedPattern(username, timestamp, website) {
  const order = username.map((_, i) => i).sort((a, b) => timestamp[a] - timestamp[b]);
  const visits = new Map(); // user -> websites in time order
  for (const i of order) {
    if (!visits.has(username[i])) visits.set(username[i], []);
    visits.get(username[i]).push(website[i]);
  }

  const count = new Map(); // JSON-encoded pattern -> number of users
  for (const sites of visits.values()) {
    const seen = new Set();
    for (let i = 0; i < sites.length; i++) {
      for (let j = i + 1; j < sites.length; j++) {
        for (let k = j + 1; k < sites.length; k++) {
          seen.add(JSON.stringify([sites[i], sites[j], sites[k]]));
        }
      }
    }
    for (const key of seen) count.set(key, (count.get(key) || 0) + 1);
  }

  const smaller = (a, b) => {
    for (let i = 0; i < 3; i++) {
      if (a[i] !== b[i]) return a[i] < b[i];
    }
    return false;
  };
  let best = null;
  let bestCount = 0;
  for (const [key, c] of count) {
    const pattern = JSON.parse(key);
    if (c > bestCount || (c === bestCount && smaller(pattern, best))) {
      best = pattern;
      bestCount = c;
    }
  }
  return best;
}

Ask the clarifying questions first: can websites repeat in a pattern, do the visits need to be consecutive, and how ties are broken. Interviewers often ask this problem mainly to see whether you pin those down.

Then say the cost honestly. The triple enumeration is cubic in the number of visits per user, which is fine because individual users have few visits, but call it out and mention that the per-user set is what keeps counts correct.