How do you solve Consecutive Numbers on LeetCode?

Consecutive Numbers (LeetCode #180) can be solved using Brute Force or Optimal Solution. The optimal approach is Optimal Solution with O(n) time complexity and O(n) space complexity. Key insight: Consecutive counting requires careful tracking of the previous number.

What is the time complexity of Consecutive Numbers?

The optimal solution for Consecutive Numbers runs in O(n) time and uses O(n) space. This complexity is linear because we only traverse the logs once, maintaining a count of consecutive occurrences.

What is the brute force solution for Consecutive Numbers?

The brute force approach for Consecutive Numbers is Brute Force, with O(n²) time complexity and O(1) space complexity. The brute-force approach checks every possible sequence of numbers in the logs to see if any number appears consecutively three times. This is straightforward but inefficient as it involves nested loops. The optimal Optimal Solution approach improves this to O(n).

What algorithm or data structure is used to solve Consecutive Numbers?

Consecutive Numbers uses the following concepts: Database. The recommended patterns to study are: Hash Map, Array.

What are the interview tips for Consecutive Numbers?

Clearly explain your thought process as you write the SQL query. Be mindful of edge cases, such as when there are fewer than three consecutive numbers. Practice writing SQL queries on paper or a whiteboard to simulate interview conditions.

What are common mistakes when solving Consecutive Numbers?

Not resetting the count when the number changes. Failing to account for the last sequence of numbers.

#180

Consecutive Numbers

Medium

DatabaseHash MapArray

LeetCode ↗

Approaches

Brute ForceOptimal

Complexity Comparison

	Brute Force	Optimal Solution★
Time	O(n²)	O(n)
Space	O(1)	O(n)

💡

Intuition

Time O(n)Space O(n)

The optimal solution uses a single pass through the logs while maintaining a count of consecutive occurrences. This is efficient because it only requires one traversal of the data.

⚙️

Algorithm

6 steps

1Step 1: Initialize a variable to keep track of the current number and its count.
2Step 2: Loop through the logs and for each number, check if it is the same as the previous one.
3Step 3: If it is the same, increment the count; if not, reset the count to 1.
4Step 4: If the count reaches 3, add the number to a result set.
5Step 5: Continue until all logs are processed.
6Step 6: Return the result set.

solution.py16 lines

1# Full working Python code
2SELECT DISTINCT num AS ConsecutiveNums
3FROM (
4    SELECT num,
5           COUNT(*) AS count
6    FROM (
7        SELECT num,
8               @prev AS prev,
9               @count := IF(num = @prev, @count + 1, 1) AS count,
10               @prev := num
11        FROM Logs,
12        (SELECT @prev := NULL, @count := 0) AS init
13        ORDER BY id
14    ) AS subquery
15    WHERE count >= 3
16) AS final_result;

ℹ

Complexity note: This complexity is linear because we only traverse the logs once, maintaining a count of consecutive occurrences.

1Consecutive counting requires careful tracking of the previous number.
2Using a single pass can significantly improve performance.

Solutions and explanations are original Tejav content. Problem titles © LeetCode — use the LeetCode button above for the full problem statement.