Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Check if a number can be expressed as a sum of consecutive numbers

  • Difficulty Level : Medium
  • Last Updated : 22 Nov, 2021

Given a number n, the task is to check whether it can be expressed as a sum of two or more consecutive numbers or not. 
Examples: 
 

Input  : n = 10 
Output : true
It can be expressed as sum of two consecutive
numbers 1 + 2 + 3 + 4.

Input  : n = 16  
Output : false
It cannot be expressed as sum of two consecutive
numbers.

Input  : n = 5  
Output : true
2 + 3 = 5

 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

There is a direct and quick method to solve this. If a number is a power of two, then it cannot be expressed as a sum of consecutive numbers otherwise Yes.
The idea is based on below two facts. 
1) Sum of any two consecutive numbers is odd as one of them has to be even and the other odd. 
2) 2n = 2n-1 + 2n-1
If we take a closer look at 1) and 2), we can get the intuition behind the fact.
Below is the implementation of the above idea. 
 

C++




// C++ program to check if a number can
// be expressed as sum of consecutive numbers
#include<bits/stdc++.h>
using namespace std;
 
// This function returns true if n can be
// expressed sum of consecutive.
bool canBeSumofConsec(unsigned int n)
{
    // We basically return true if n is a
    // power of two
    return ((n&(n-1)) && n);
}
 
// Driver code
int main()
{
    unsigned int n = 15;
    canBeSumofConsec(n)? cout << "true" :
                         cout << "false";
    return 0;
}
Java



// Java program to check if a number can
// be expressed as sum of consecutive numbers
 
class Test
{
    // This function returns true if n can be
    // expressed sum of consecutive.
    static boolean canBeSumofConsec(int n)
    {
        // We basically return true if n is a
        // power of two
        return (((n&(n-1))!=0) && n!=0);
    }
     
    // Driver method
    public static void main(String[] args)
    {
        int n = 15;
        System.out.println(canBeSumofConsec(n) ? "true" : "false");
    }
}
Python3



# Python 3 program to check if a number can
# be expressed as sum of consecutive numbers
 
 
# This function returns true if n
# can be expressed sum of consecutive.
def canBeSumofConsec(n) :
 
    # We basically return true if n is a
    # power of two
    return ((n&(n-1)) and n)
 
 
# Driver code
n = 15
if(canBeSumofConsec(n)) :
    print("true")
else :
    print("false")
     
# This code is contributed by Nikita Tiwari.
C#



// C# program to check if a number can be
// expressed as sum of consecutive numbers
using System;
 
class Test
{
    // This function returns true if n
    // can be expressed sum of consecutive.
    static bool canBeSumofConsec(int n)
    {
        // We basically return true if n is a
        // power of two
        return (((n & (n - 1)) != 0) && n != 0);
    }
     
    // Driver Code
    public static void Main()
    {
        int n = 15;
        Console.Write(canBeSumofConsec(n) ? "True" : "False");
    }
}
 
// This code is contributed by Nitin Mittal.
PHP



<?php
// php program to check if a number
// can be expressed as sum of
// consecutive numbers
 
// This function returns true if n
// can be expressed sum of consecutive.
function canBeSumofConsec($n)
{
     
    // We basically return true if n is a
    // power of two
    return (($n & ($n - 1)) && $n);
}
 
// Driver code
    $n = 15;
    if(canBeSumofConsec($n))
        echo "true" ;
    else
        echo "false";
 
// This code is contributed by
// nitin mittal.
?>
Javascript



<script>
 
// Javascript program to check if a number can
// be expressed as sum of consecutive numbers
 
 
    // This function returns true if n can be
    // expressed sum of consecutive.
    function canBeSumofConsec(n)
    {
        // We basically return true if n is a
        // power of two
        return (((n&(n-1))!=0) && n!=0);
    }
       
       
// function call
     
    let n = 15;
    document.write(canBeSumofConsec(n) ? "true" : "false");
     
</script>
Output: 


True
Time Complexity: O(1)
Auxiliary Space: O(1)
Another Approach :
Let number chosen to represent N as a sum of consecutive numbers be X + 1, X + 2, X + 3 …. Y 
Sum of these chosen numbers = Sum of first Y natural numbers – Sum of first X natural number 
Sum of first Y natural number = \frac {Y \cdot (Y + 1)} {2}
Sum of first X natural number = \frac {X \cdot (X + 1)} {2}
We know that, 
N = Sum of first Y natural number - Sum of first X natural number
N = \frac {Y \cdot (Y + 1)} {2} - \frac {X \cdot (X + 1)} {2}
2N = Y \cdot (Y + 1) - X \cdot (X + 1)
2N = Y ^ 2 - X ^ 2 + Y - X
2N = (Y - X) \cdot (Y + X + 1)
Let Y - X = a, Y + X + 1 = b 
Y + X + 1 > Y - X, b > a
X = \frac {a - b - 1} {2}, Y = \frac {a + b + 1} {2}
2N = a * b
It means that a and b are factor of 2N, we know that X and Y are integers so, 
1. b - a - 1 => multiple of 2 (Even number) 
2. b + a + 1 => multiple of 2 (Even number)
Both conditions must be satisfied
From 1 and 2 we can say that either one of them (a, b) should be Odd and another one Even
So if the number (2N) has only odd factors (can’t be possible as it is an even number (2N not N) ) or only even factors we can’t represent it as a sum of any consecutive natural numbers
So now, we have to now only check whether it has an odd factor or not


1. If the number (2N not N) does not have any odd factor (contains only even factor means can be represented as 2 ^ k               ) then we can’t represent it as a sum of consecutive number
2. If the number (2N not N) has an odd factor then we can represent it as a sum of a consecutive number
After this we have to only check whether we can represent (2N as 2^k) or not 
if Yes then answer is false or 0
if No then answer is true or 1
Below is the implementation of the above idea : 
C++14



#include <bits/stdc++.h>
using namespace std;
 
long long int canBeSumofConsec(long long int n)
{
    // Updating n with 2n
    n = 2 * n;
    // (n & (n - 1)) => Checking whether we can write 2n as 2^k
    // if yes (can't represent 2n as 2^k) then answer 1
    // if no (can represent 2n as 2^k) then answer 0
    return ((n & (n - 1)) != 0);
}
 
int main()
{
    long long int n = 10;
    cout<<canBeSumofConsec(n)<<"\n";
}
C



#include <stdio.h>
 
long long int canBeSumofConsec(long long int n)
{
    // Updating n with 2n
    n = 2 * n;
    // (n & (n - 1)) => Checking whether we can write 2n as 2^k
    // if yes (can't represent 2n as 2^k) then answer 1
    // if no (can represent 2n as 2^k) then answer 0
    return ((n & (n - 1)) != 0);
}
 
int main()
{
    long long int n = 10;
    printf("%lld", canBeSumofConsec(n));
}
Java



import java.util.*;
class GFG{
 
 static int canBeSumofConsec( int n)
{
    // Updating n with 2n
    n = 2 * n;
    
    // (n & (n - 1)) => Checking whether we can write 2n as 2^k
    // if yes (can't represent 2n as 2^k) then answer 1
    // if no (can represent 2n as 2^k) then answer 0
    return ((n & (n - 1)) != 0)?1:0;
}
 
public static void main(String[] args)
{
    int n = 10;
    System.out.print(canBeSumofConsec(n)+"\n");
}
}
 
// This code is contributed by umadevi9616
Python3



def canBeSumofConsec(n):
   
    # Updating n with 2n
    n = 2 * n;
 
    # (n & (n - 1)) => Checking whether we can write 2n as 2^k
    # if yes (can't represent 2n as 2^k) then answer 1
    # if no (can represent 2n as 2^k) then answer 0
    if((n & (n - 1)) != 0):
        return 1;
    else:
        return 0;
 
if __name__ == '__main__':
    n = 10;
    print(canBeSumofConsec(n));
 
# This code is contributed by umadevi9616
C#



using System;
 
public class GFG {
 
    static int canBeSumofConsec(int n)
    {
       
        // Updating n with 2n
        n = 2 * n;
 
        // (n & (n - 1)) => Checking whether we can write 2n as 2^k
        // if yes (can't represent 2n as 2^k) then answer 1
        // if no (can represent 2n as 2^k) then answer 0
        return ((n & (n - 1)) != 0) ? 1 : 0;
    }
 
    public static void Main(String[] args) {
        int n = 10;
        Console.Write(canBeSumofConsec(n) + "\n");
    }
}
 
// This code is contributed by umadevi9616
Javascript



<script>
 
    function canBeSumofConsec(n) {
        // Updating n with 2n
        n = 2 * n;
 
        // (n & (n - 1)) => Checking whether we can write 2n as 2^k
        // if yes (can't represent 2n as 2^k) then answer 1
        // if no (can represent 2n as 2^k) then answer 0
        return ((n & (n - 1)) != 0) ? 1 : 0;
    }
 
        var n = 10;
        document.write(canBeSumofConsec(n) + "\n");
 
// This code is contributed by umadevi9616
</script>
Output
1
Time Complexity: O(1)
Auxiliary Space: O(1)
Reference: 
http://www.cut-the-knot.org/arithmetic/UnpropertyOfPowersOf2.shtml
This article is contributed by Sahil Chhabra(KILLER). If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 



My Personal Notes
arrow_drop_up
Previous
Express a number as sum of consecutive numbers
Next

Highest power of 2 less than or equal to given number
Recommended Articles
Page :
Count prime numbers that can be expressed as sum of consecutive prime numbers
10, Sep 20
Check if a given number can be expressed as pair-sum of sum of first X natural numbers
12, Sep 20
Check if a prime number can be expressed as sum of two Prime Numbers
22, Nov 18
Check if a number can be expressed as sum two abundant numbers
10, Jan 19
Count primes that can be expressed as sum of two consecutive primes and 1
12, Feb 19
Count numbers up to N that cannot be expressed as sum of at least two consecutive positive integers
03, May 21
Check whether a number can be expressed as a product of single digit numbers
17, Sep 17
Check if a number N can be expressed as the sum of powers of X or not
25, May 21
Check if a number can be expressed as sum of two Perfect powers
18, Aug 20
Number expressed as sum of five consecutive integers
01, Jun 18
Check if a number can be expressed as product of a prime and a composite number
11, Nov 21
Check if N can be expressed as product of 3 distinct numbers
30, Mar 20
Count numbers up to N that can be expressed as powers of Prime Numbers
15, Mar 21
Check if an integer can be expressed as a sum of two semi-primes
22, Oct 18
Find ways an Integer can be expressed as sum of n-th power of unique natural numbers
23, Mar 17
Count numbers from a given range that can be expressed as sum of digits raised to the power of count of digits
02, Mar 21
Check if a number can be expressed as x^y (x raised to power y)
20, Oct 15
Check if a number can be expressed as power | Set 2 (Using Log)
13, May 18
Check if a number can be expressed as a^b | Set 2
06, Oct 18
Check if a number can be expressed as 2^x + 2^y
14, Sep 18
Check if a number N can be expressed in base B
04, Aug 20
Program to check if a number can be expressed as an even power of 2 or not
09, Mar 21
Check if a number can be expressed as a product of exactly K prime divisors
22, Apr 20
Print numbers such that no two consecutive numbers are co-prime and every three consecutive numbers are co-prime
22, Jan 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!