Calculate sum of all integers from 1 to N, excluding perfect power of 2

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 log₂N, 
Let r = log₂N 
And the sum of all numbers which are perfect power of 2 is given by 2^r - 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++ 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 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

# 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# 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

<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>                    

0

Time Complexity: O(1)

Auxiliary Space: O(1)