Skip to content
Related Articles

Related Articles

Calculate sum of all integers from 1 to N, excluding perfect power of 2
  • Last Updated : 13 Apr, 2021

Given a positive integer N, the task is to calculate the sum of all integers from 1 to N but excluding the number which is a perfect power of 2.
Examples: 
 

Input: N = 2 
Output: 0
Input: N = 1000000000 
Output: 499999998352516354 
 

 

Naive Approach: 
The naive approach is to iterate every number from 1 to N and compute the sum in the variable by excluding the number which is a perfect power of 2. But to compute the sum to the number 10^9, the above approach will give Time Limit Error.
Time Complexity: O(N)
Efficient Approach: 
To find desired sum, below are the steps: 
 

  1. Find the sum of all the number till N using the formula discussed in this article in O(1) time.
  2. Since sum of all perfect power of 2 forms a Geometric Progression. Hence the sum of all powers of 2 less than N is calculated by the below formula: 
     

The number of element with perfect power of 2 less than N is given by log2N
Let r = log2
And the sum of all numbers which are perfect power of 2 is given by 2r – 1
 



  1.  
  2. Subtract the sum of all perfect powers of 2 calculated above from the sum of first N numbers to get the result.

Below is the implementation of the above approach: 
 

C++




// C++ implementation of the
// approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the required
// summation
void findSum(int N)
{
    // Find the sum of first N
    // integers using the formula
    int sum = (N) * (N + 1) / 2;
     
    int r = log2(N) + 1;
     
    // Find the sum of numbers
    // which are exact power of
    // 2 by using the formula
    int expSum = pow(2, r) - 1;   
 
    // Print the final Sum
    cout << sum - expSum << endl;
}
 
// Driver's Code
int main()
{
    int N = 2;
 
    // Function to find the
    // sum
    findSum(N);
    return 0;
}

Java




// Java implementation of the above approach
import java.lang.Math;
 
class GFG{
     
// Function to find the required
// summation
public static void findSum(int N)
{
 
    // Find the sum of first N
    // integers using the formula
    int sum = (N) * (N + 1) / 2;
         
    int r = (int)(Math.log(N) /
                  Math.log(2)) + 1;
         
    // Find the sum of numbers
    // which are exact power of
    // 2 by using the formula
    int expSum = (int)(Math.pow(2, r)) - 1;    
     
    // Print the final Sum
    System.out.println(sum - expSum);
}
 
// Driver Code
public static void main(String[] args)
{
    int N = 2;
 
    // Function to find the sum
    findSum(N);
}
}
 
// This code is contributed by divyeshrabadiya07

Python3




# Python 3 implementation of the
# approach
from math import log2,pow
 
# Function to find the required
# summation
def findSum(N):
    # Find the sum of first N
    # integers using the formula
    sum = (N) * (N + 1) // 2
     
    r = log2(N) + 1
     
    # Find the sum of numbers
    # which are exact power of
    # 2 by using the formula
    expSum = pow(2, r) - 1
 
    # Print the final Sum
    print(int(sum - expSum))
 
# Driver's Code
if __name__ == '__main__':
    N = 2
 
    # Function to find the
    # sum
    findSum(N)
     
# This code is contributed by Surendra_Gangwar

C#




// C# implementation of the above approach
using System;
 
class GFG{
     
// Function to find the required
// summation
public static void findSum(int N)
{
 
    // Find the sum of first N
    // integers using the formula
    int sum = (N) * (N + 1) / 2;
         
    int r = (int)(Math.Log(N) /
                  Math.Log(2)) + 1;
         
    // Find the sum of numbers
    // which are exact power of
    // 2 by using the formula
    int expSum = (int)(Math.Pow(2, r)) - 1;
     
    // Print the final Sum
    Console.Write(sum - expSum);
}
 
// Driver Code
public static void Main(string[] args)
{
    int N = 2;
 
    // Function to find the sum
    findSum(N);
}
}
 
// This code is contributed by rutvik_56

Javascript




<script>
 
// Javascript implementation of the above approach
 
// Function to find the required
// summation
function findSum(N)
{
     
    // Find the sum of first N
    // integers using the formula
    var sum = (N) * (N + 1) / 2;
         
    var r = (Math.log(N) /
             Math.log(2)) + 1;
         
    // Find the sum of numbers
    // which are exact power of
    // 2 by using the formula
    var expSum = (Math.pow(2, r)) - 1;    
     
    // Print the final Sum
    document.write(sum - expSum);
}
     
// Driver code
var N = 2;
 
// Function to find the sum
findSum(N);
 
// This code is contributed by Kirti
 
</script>
Output: 
0

 

Time Complexity: O(1)
 

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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :