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. 

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)

Auxiliary Space: O(1)