Open In App

Count ways to express a number as sum of consecutive numbers

Last Updated : 23 Jun, 2022
Improve
Improve
Like Article
Like
Save
Share
Report

Given an integer N, the task is to find the number of ways to represent this number as a sum of 2 or more consecutive natural numbers.

Examples: 
 

Input: N = 15 
Output:
Explanation: 
15 can be represented as: 
 

  1. 1 + 2 + 3 + 4 + 5
  2. 4 + 5 + 6
  3. 7 + 8

Input: N = 10 
Output:
 

 

Recommended Practice

 

Approach: The idea is to represent N as a sequence of length L+1 as: 
N = a + (a+1) + (a+2) + .. + (a+L) 
=> N = (L+1)*a + (L*(L+1))/2 
=> a = (N- L*(L+1)/2)/(L+1) 
We substitute the values of L starting from 1 till L*(L+1)/2 < N 
If we get ‘a’ as a natural number then the solution should be counted.
 

 

?list=PLM68oyaqFM7Q-sv3gA5xbzfgVkoQ0xDrW
 

C++




// C++ program to count number of ways to express
// N as sum of consecutive numbers.
#include <bits/stdc++.h>
using namespace std;
 
long int countConsecutive(long int N)
{
    // constraint on values of L gives us the
    // time Complexity as O(N^0.5)
    long int count = 0;
    for (long int L = 1; L * (L + 1) < 2 * N; L++) {
        double a = (1.0 * N - (L * (L + 1)) / 2) / (L + 1);
        if (a - (int)a == 0.0)
            count++;
    }
    return count;
}
 
// Driver Code
int main()
{
    long int N = 15;
    cout << countConsecutive(N) << endl;
    N = 10;
    cout << countConsecutive(N) << endl;
    return 0;
}


Java




// A Java program to count number of ways
// to express N as sum of consecutive numbers.
public class SumConsecutiveNumber {
    // Utility method to compute number of ways
    // in which N can be represented as sum of
    // consecutive number
    static int countConsecutive(int N)
    {
        // constraint on values of L gives us the
        // time Complexity as O(N^0.5)
        int count = 0;
        for (int L = 1; L * (L + 1) < 2 * N; L++) {
            double a = (double)((1.0 * N - (L * (L + 1)) / 2) / (L + 1));
            if (a - (int)a == 0.0)
                count++;
        }
        return count;
    }
 
    // Driver code to test above function
    public static void main(String[] args)
    {
        int N = 15;
        System.out.println(countConsecutive(N));
        N = 10;
        System.out.println(countConsecutive(N));
    }
}
// This code is contributed by Sumit Ghosh


Python3




# Python program to count number of ways to
# express N as sum of consecutive numbers.
 
def countConsecutive(N):
     
    # constraint on values of L gives us the
    # time Complexity as O(N ^ 0.5)
    count = 0
    L = 1
    while( L * (L + 1) < 2 * N):
        a = (1.0 * N - (L * (L + 1) ) / 2) / (L + 1)
        if (a - int(a) == 0.0):
            count += 1
        L += 1
    return count
 
# Driver code
 
N = 15
print (countConsecutive(N))
N = 10
print (countConsecutive(N))
 
# This code is contributed by Sachin Bisht


C#




// A C# program to count number of
// ways to express N as sum of
// consecutive numbers.
using System;
 
public class GFG {
 
    // Utility method to compute
    // number of ways in which N
    // can be represented as sum
    // of consecutive number
    static int countConsecutive(int N)
    {
 
        // constraint on values of L
        // gives us the time
        // Complexity as O(N^0.5)
        int count = 0;
        for (int L = 1; L * (L + 1)
                        < 2 * N;
             L++) {
            double a = (double)((1.0
                                   * N
                               - (L * (L + 1))
                                     / 2)
                              / (L + 1));
 
            if (a - (int)a == 0.0)
                count++;
        }
 
        return count;
    }
 
    // Driver code to test above
    // function
    public static void Main()
    {
        int N = 15;
        Console.WriteLine(
            countConsecutive(N));
 
        N = 10;
        Console.Write(
            countConsecutive(N));
    }
}
 
// This code is contributed by
// nitin mittal.


PHP




<?php
// PHP program to count number
// of ways to express N as sum
// of consecutive numbers.
 
function countConsecutive($N)
{
    // constraint on values
    // of L gives us the
    // time Complexity as O(N^0.5)
    $count = 0;
    for ($L = 1;
         $L * ($L + 1) < 2 * $N; $L++)
    {
        $a = (int)(1.0 * $N - ($L *
             (int)($L + 1)) / 2) / ($L + 1);
        if ($a - (int)$a == 0.0)
            $count++;
    }
    return $count;
}
 
// Driver Code
$N = 15;
echo countConsecutive($N), "\n";
$N = 10;
echo countConsecutive($N), "\n";
 
// This code is contributed by ajit
?>


Javascript




<script>
    // A Javascript program to count number of
    // ways to express N as sum of
    // consecutive numbers.
     
    // Utility method to compute
    // number of ways in which N
    // can be represented as sum
    // of consecutive number
    function countConsecutive(N)
    {
           
        // constraint on values of L
        // gives us the time
        // Complexity as O(N^0.5)
        let count = 0;
        for (let L = 1; L * (L + 1) < 2 * N; L++)
        {
            let a = ((1.0 * N-(L * (L + 1)) / 2) / (L + 1));
                        
            if (a - parseInt(a, 10) == 0.0)
                count++;    
        }
           
        return count;
    }
     
    let N = 15;
    document.write(countConsecutive(N) + "</br>");
 
    N = 10;
    document.write(countConsecutive(N));
     
</script>


 
 

Output: 

3
1

 

 

Time Complexity: O(N^0.5)

Auxiliary Space: O(1)

 

 

 



Like Article
Suggest improvement
Previous
Next
Share your thoughts in the comments

Similar Reads