Is Find Users with Persistent Behavior Patterns easy or hard?

It is rated Hard on FleetCode with a 47.6 percent acceptance rate. The difficulty comes from recognizing that persistence is a consecutive-run problem, not a simple count. Once you see the run key pattern, the implementation is short.

How to solve Find Users with Persistent Behavior Patterns in O(n)?

Use a single pass over rows already sorted by user and period. Keep a running streak counter per user that resets when the condition breaks or the period gap exceeds one. If the table is not sorted, the sort step adds O(n log n), so O(n) requires sorted input or a hash-based grouping pass.

Find Users with Persistent Behavior Patterns Python or Java solution?

In Python, use Pandas: filter with a boolean mask, sort by user and period, compute a run key with cumulative counts, then groupby and aggregate. In Java, sort records by user and period, then iterate once with a streak counter that resets on a break. Both run in O(n log n) time.

What is the best approach for Find Users with Persistent Behavior Patterns?

The best approach is gaps-and-islands with grouping and aggregation. Filter the qualifying rows first, compute a run key that stays constant across consecutive periods, then group by user and run key. This runs in O(n log n) time with O(n) space.

What data structure is used in Find Users with Persistent Behavior Patterns?

The problem is usually solved with a relational table and grouping operations rather than a classic data structure. In Pandas, you use a DataFrame with groupby and aggregation. In SQL, you use window functions such as ROW_NUMBER to build the run key, then GROUP BY on user and that key.

What is the time complexity of Find Users with Persistent Behavior Patterns?

The optimal solution runs in O(n log n) time, where n is the number of activity rows, because the grouping or sorting step dominates. A brute force self-join runs in O(n^2) time. Both approaches use O(n) extra space in the optimal case.

Is Find Users with Persistent Behavior Patterns asked at Google, Amazon, or Meta?

FleetCode does not tag this problem to a specific company. Consecutive-run and gaps-and-islands questions are common in SQL and data engineering interviews at large tech companies, so the underlying pattern is worth knowing even if this exact problem does not appear.

Description Solution Video 10:27

3832. Find Users with Persistent Behavior Patterns

Hard47.6% acceptance

Table: activity

+--------------+---------+
| Column Name  | Type    |
+--------------+---------+
| user_id      | int     |
| action_date  | date    |
| action       | varchar |
+--------------+---------+
(user_id, action_date, action) is the primary key (unique value) for this table.
Each row represents a user performing a specific action on a given date.

Write a solution to identify behaviorally stable users based on the following definition:

A user is considered behaviorally stable if there exists a sequence of at least 5 consecutive days such that:
- The user performed exactly one action per day during that period.
- The action is the same on all those consecutive days.
If a user has multiple qualifying sequences, only consider the sequence with the maximum length.

Return the result table ordered by streak_length in descending order, then by user_id in ascending order.

The result format is in the following example.

Example:

Input:

activity table:

+---------+-------------+--------+
| user_id | action_date | action |
+---------+-------------+--------+
| 1       | 2024-01-01  | login  |
| 1       | 2024-01-02  | login  |
| 1       | 2024-01-03  | login  |
| 1       | 2024-01-04  | login  |
| 1       | 2024-01-05  | login  |
| 1       | 2024-01-06  | logout |
| 2       | 2024-01-01  | click  |
| 2       | 2024-01-02  | click  |
| 2       | 2024-01-03  | click  |
| 2       | 2024-01-04  | click  |
| 3       | 2024-01-01  | view   |
| 3       | 2024-01-02  | view   |
| 3       | 2024-01-03  | view   |
| 3       | 2024-01-04  | view   |
| 3       | 2024-01-05  | view   |
| 3       | 2024-01-06  | view   |
| 3       | 2024-01-07  | view   |
+---------+-------------+--------+

Output:

+---------+--------+---------------+------------+------------+
| user_id | action | streak_length | start_date | end_date   |
+---------+--------+---------------+------------+------------+
| 3       | view   | 7             | 2024-01-01 | 2024-01-07 |
| 1       | login  | 5             | 2024-01-01 | 2024-01-05 |
+---------+--------+---------------+------------+------------+

Explanation:

User 1:
- Performed login from 2024-01-01 to 2024-01-05 on consecutive days
- Each day has exactly one action, and the action is the same
- Streak length = 5 (meets minimum requirement)
- The action changes on 2024-01-06, ending the streak
User 2:
- Performed click for only 4 consecutive days
- Does not meet the minimum streak length of 5
- Excluded from the result
User 3:
- Performed view for 7 consecutive days
- This is the longest valid sequence for this user
- Included in the result

The Results table is ordered by streak_length in descending order, then by user_id in ascending order

10:27

Still stuck?Read the written solution, or watch a walkthrough.

Open solution

LanguageLoading editor…

1# Write your MySQL query statement below

Starter codeMySQLSpaces: 4

Examples

Case 1

Input

{"headers":{"activity":["user_id","action_date","action"]},"rows":{"activity":[[1,"2024-01-01","login"],[1,"2024-01-02","login"],[1,"2024-01-03","login"],[1,"2024-01-04","login"],[1,"2024-01-05","login"],[1,"2024-01-06","logout"],[2,"2024-01-01","click"],[2,"2024-01-02","click"],[2,"2024-01-03","click"],[2,"2024-01-04","click"],[3,"2024-01-01","view"],[3,"2024-01-02","view"],[3,"2024-01-03","view"],[3,"2024-01-04","view"],[3,"2024-01-05","view"],[3,"2024-01-06","view"],[3,"2024-01-07","view"]]}}

Your code is saved on this device.Solution