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:
- Find the sum of all the number till N using the formula discussed in this article in O(1) time.
- 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 = log2N
And the sum of all numbers which are perfect power of 2 is given by 2r – 1.
- 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)