Problem Description

You are given an integer num. Your task is to find three consecutive integers that add up to num.

The three integers must be consecutive, meaning they follow one after another with no gaps (like 5, 6, 7 or -2, -1, 0).

Return these three consecutive integers as a sorted array. If it's impossible to express num as the sum of three consecutive integers, return an empty array.

For example:

• If num = 33, you can return [10, 11, 12] because 10 + 11 + 12 = 33
• If num = 4, you would return an empty array [] because 4 cannot be expressed as the sum of three consecutive integers

The solution uses a mathematical approach: if three consecutive integers are x-1, x, and x+1, their sum equals (x-1) + x + (x+1) = 3x. This means num must be divisible by 3 for a valid solution to exist. If num is divisible by 3, then x = num/3, and the three consecutive integers are [x-1, x, x+1].

Intuition

When looking for three consecutive integers, let's think about their structure. If we have three consecutive numbers, we can represent them as some middle number and its neighbors. For instance, if the middle number is x, then the three consecutive integers would be x-1, x, and x+1.

Now, what happens when we add these three numbers together?

• Sum = (x-1) + x + (x+1)
• Sum = x - 1 + x + x + 1
• Sum = 3x

This reveals a key insight: the sum of any three consecutive integers is always exactly 3 times the middle number!

This means two important things:

1. The given num must be divisible by 3 for a solution to exist (since num = 3x means x = num/3 must be a whole number)
2. If num is divisible by 3, we can immediately find the middle number by dividing num by 3

Once we have the middle number x, constructing the answer is straightforward - just return [x-1, x, x+1]. If num is not divisible by 3, no three consecutive integers can sum to it, so we return an empty array.

This mathematical relationship transforms what could be a search problem into a simple arithmetic check and calculation.

Learn more about Math patterns.

Solution Approach

The implementation follows directly from our mathematical insight that three consecutive integers x-1, x, and x+1 sum to 3x.

Here's how the solution works step by step:

1. Check divisibility by 3: We use Python's divmod() function to simultaneously get both the quotient and remainder when dividing num by 3:

   x, mod = divmod(num, 3)

   • x stores the quotient (num // 3), which would be our middle number if valid
   • mod stores the remainder (num % 3)

2. Determine if a solution exists: We check if mod is 0:

   • If mod != 0, then num is not divisible by 3, meaning no three consecutive integers can sum to it. We return an empty list []
   • If mod == 0, then num is divisible by 3, and we can construct our answer

3. Construct the result: When a valid solution exists (i.e., mod == 0), we return the three consecutive integers:

   [x - 1, x, x + 1]

   where x is the middle number we calculated as num // 3

The entire solution is elegantly expressed in a single line using a conditional expression:

return [] if mod else [x - 1, x, x + 1]

This returns an empty list if mod is non-zero (truthy), otherwise returns the three consecutive integers centered around x.

The time complexity is O(1) since we only perform constant-time arithmetic operations, and the space complexity is O(1) as we only use a fixed amount of extra space.

Example Walkthrough

Let's walk through the solution with num = 33:

1. Apply the mathematical formula: We know that three consecutive integers (x-1), x, and (x+1) sum to 3x. So if num = 33, we need to check if 33 can be expressed as 3x.

2. Check divisibility and find the middle number:

   x, mod = divmod(33, 3)
   # x = 11 (quotient)
   # mod = 0 (remainder)

   Since 33 ÷ 3 = 11 with remainder 0, we know:

   • A solution exists (remainder is 0)
   • The middle number is 11

3. Construct the three consecutive integers:

   • First number: x - 1 = 11 - 1 = 10
   • Middle number: x = 11
   • Third number: x + 1 = 11 + 1 = 12

4. Verify: 10 + 11 + 12 = 33 ✓

5. Return result: [10, 11, 12]

Now let's see a case where no solution exists with num = 4:

1. Check divisibility:

   x, mod = divmod(4, 3)
   # x = 1 (quotient)
   # mod = 1 (remainder)

2. Determine if solution exists: Since mod = 1 (not 0), we know that 4 cannot be evenly divided by 3. This means 4 cannot be expressed as the sum of three consecutive integers.

3. Return result: [] (empty array)

The key insight is that any sum of three consecutive integers must be divisible by 3, making this check both necessary and sufficient for determining whether a solution exists.

Solution Implementation

Time and Space Complexity

The time complexity is O(1) because the algorithm performs a fixed number of operations regardless of the input size. The divmod() function computes both the quotient and remainder in constant time, and creating a list with three elements (or an empty list) also takes constant time.

The space complexity is O(1) because the algorithm uses a constant amount of extra space. It only creates two variables (x and mod) and returns either an empty list or a list with exactly three elements, both of which require constant space that doesn't scale with the input.

Learn more about how to find time and space complexity quickly.

Common Pitfalls

1. Integer Overflow in Other Languages

While Python handles arbitrarily large integers gracefully, implementing this solution in languages like Java or C++ could lead to integer overflow issues when calculating x - 1 or x + 1 for extremely large values of num.

Example scenario: If num is close to Integer.MAX_VALUE in Java, calculating x + 1 might overflow.

Solution:

• In languages with fixed integer sizes, check for potential overflow before performing arithmetic operations
• Use long/int64 data types when dealing with large inputs
• Add boundary checks: verify that x - 1 and x + 1 are within valid integer ranges

2. Misunderstanding the Problem Requirements

A common mistake is trying to find ANY three numbers that sum to num, rather than three CONSECUTIVE integers. Some might incorrectly attempt solutions like finding three equal numbers (num/3, num/3, num/3) or arbitrary combinations.

Solution:

• Always remember the consecutive constraint: the numbers must be n, n+1, n+2 for some integer n
• The mathematical relationship 3x = num only works because we're looking for consecutive integers

3. Incorrect Handling of Negative Numbers

Developers might assume the solution only works for positive numbers, but the algorithm correctly handles negative values as well. For example, num = -6 yields [-3, -2, -1].

Solution:

• The algorithm naturally handles negative numbers through integer division
• No special cases needed for negative inputs - the math works universally

4. Forgetting to Return Sorted Order

While the current solution naturally returns integers in ascending order [x-1, x, x+1], modifying the approach might accidentally return unsorted results.

Solution:

• Always construct the result as [x-1, x, x+1] to maintain sorted order
• If using a different approach, explicitly sort the result before returning