Consecutive Numbers Sum - Practice Coding Problems

Consecutive Numbers Sum - Problem

Math Enumeration Hard

Consecutive Numbers Sum

Given a positive integer n, determine how many different ways you can express n as the sum of consecutive positive integers.

For example, the number 9 can be written as:
• 9 (single number)
• 4 + 5 (two consecutive numbers)
• 2 + 3 + 4 (three consecutive numbers)

So there are 3 ways to write 9 as a sum of consecutive positive integers.

Your task: Return the total count of such representations for any given positive integer n.

Input & Output

example_1.py — Basic Case

$ Input: n = 5

› Output: 2

💡 Note: 5 can be written as: (1) 5 itself, (2) 2 + 3. So there are 2 ways total.

example_2.py — Multiple Ways

$ Input: n = 9

› Output: 3

💡 Note: 9 can be written as: (1) 9 itself, (2) 4 + 5, (3) 2 + 3 + 4. So there are 3 ways total.

example_3.py — Single Way

$ Input: n = 3

› Output: 2

💡 Note: 3 can be written as: (1) 3 itself, (2) 1 + 2. So there are 2 ways total.

Visualization

Tap to expand

Understanding the Visualization

Single Piece

The number itself (always valid)

Two Pieces

Check if n can be split into two consecutive numbers

Three Pieces

Check if n can be split into three consecutive numbers

Continue

Keep checking until sequences become impossible

Key Takeaway

🎯 Key Insight: Use the arithmetic sequence formula sum = k × start + k × (k-1) / 2 to directly calculate if a sequence of length k is possible, reducing time complexity from O(n²) to O(√n)

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each starting position (O(n)), we may check up to O(n) consecutive numbers

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track count and current sum

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁹
n is a positive integer
Time limit: 1 second per test case

Asked in

G Google 45 ⊞ Microsoft 38 a Amazon 32 f Meta 28

The optimal approach uses the mathematical formula for arithmetic sequences. For k consecutive numbers starting at 'start', the sum equals k × start + k × (k-1) / 2. We iterate through possible sequence lengths and check if the required starting number is a positive integer, achieving O(√n) time complexity instead of the brute force O(n²) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Try every possible starting number and length of consecutive sequence
Two Pointers (Mathematical Optimization)	O(√n)	O(1)	Use mathematical formula to determine valid sequence lengths

Brute Force (Nested Loops) — Algorithm Steps

For each starting number from 1 to n/2
Keep adding consecutive numbers until sum >= n
If sum equals n, increment count
If sum exceeds n, break and try next starting number

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at 1

Try sequences starting from 1: 1, 1+2, 1+2+3, etc.

Start at 2

Try sequences starting from 2: 2, 2+3, 2+3+4, etc.

Continue

Keep trying until start > n/2

Code -

solution.c — C

#include <stdio.h>

int consecutiveNumbersSum(int n) {
    int count = 0;
    int start = 1;
    
    while (start * 2 <= n) {
        int currentSum = 0;
        int current = start;
        
        while (currentSum < n) {
            currentSum += current;
            current++;
        }
        
        if (currentSum == n) {
            count++;
        }
        
        start++;
    }
    
    return count + 1; // +1 for the number itself
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", consecutiveNumbersSum(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each starting position (O(n)), we may check up to O(n) consecutive numbers

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track count and current sum

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁹
n is a positive integer
Time limit: 1 second per test case

28.8K Views

Medium Frequency

~25 min Avg. Time

1.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler