Given two integers n and k, the task is to find whether it is possible to represent n as the sum of exactly k powers of 2. If possible then print k positive integers such that they are powers of 2 and their sum is exactly equal to n else print Impossible.
Examples:
Input: n = 9, k = 4
Output: 1 2 2 4
1, 2 and 4 are all powers of 2 and 1 + 2 + 2 + 4 = 9.Input: n = 3, k = 7
Output: Impossible
It is impossible since 3 cannot be represented as sum of 7 numbers which are powers of 2.
We have discussed one approach to solve this problem in Find k numbers which are powers of 2 and have sum N. In this post, a different approach is being discussed.
Approach:
- Create an array arr[] of size k with all elements initialized to 1 and create a variable sum = k.
- Now starting from the last element of arr[]
- If sum + arr[i] ? n then update sum = sum + arr[i] and arr[i] = arr[i] * 2.
- Else skip the current element.
- If sum = n then the contents of arr[] are the required elements.
- Else it is impossible to represent n as exactly k powers of 2.
Below is the implementation of the above approach:
// C++ implementation of the above approach #include <iostream> using namespace std;
// Function to print k numbers which are powers of two // and whose sum is equal to n void FindAllElements( int n, int k)
{ // Initialising the sum with k
int sum = k;
// Initialising an array A with k elements
// and filling all elements with 1
int A[k];
fill(A, A + k, 1);
for ( int i = k - 1; i >= 0; --i) {
// Iterating A[] from k-1 to 0
while (sum + A[i] <= n) {
// Update sum and A[i]
// till sum + A[i] is less than equal to n
sum += A[i];
A[i] *= 2;
}
}
// Impossible to find the combination
if (sum != n) {
cout << "Impossible" ;
}
// Possible solution is stored in A[]
else {
for ( int i = 0; i < k; ++i)
cout << A[i] << ' ' ;
}
} // Driver code int main()
{ int n = 12;
int k = 6;
FindAllElements(n, k);
return 0;
} |
// Java implementation of the above approach import java.util.Arrays;
public class GfG {
// Function to print k numbers which are powers of two
// and whose sum is equal to n
public static void FindAllElements( int n, int k)
{
// Initialising the sum with k
int sum = k;
// Initialising an array A with k elements
// and filling all elements with 1
int [] A = new int [k];
Arrays.fill(A, 0 , k, 1 );
for ( int i = k - 1 ; i >= 0 ; --i) {
// Iterating A[] from k-1 to 0
while (sum + A[i] <= n) {
// Update sum and A[i]
// till sum + A[i] is less than equal to n
sum += A[i];
A[i] *= 2 ;
}
}
// Impossible to find the combination
if (sum != n) {
System.out.print( "Impossible" );
}
// Possible solution is stored in A[]
else {
for ( int i = 0 ; i < k; ++i)
System.out.print(A[i] + " " );
}
}
public static void main(String []args){
int n = 12 ;
int k = 6 ;
FindAllElements(n, k);
}
} // This code is contributed by Rituraj Jain |
# Python 3 implementation of the above approach # Function to print k numbers which are # powers of two and whose sum is equal to n def FindAllElements(n, k):
# Initialising the sum with k
sum = k
# Initialising an array A with k elements
# and filling all elements with 1
A = [ 1 for i in range (k)]
i = k - 1
while (i > = 0 ):
# Iterating A[] from k-1 to 0
while ( sum + A[i] < = n):
# Update sum and A[i] till
# sum + A[i] is less than equal to n
sum + = A[i]
A[i] * = 2
i - = 1
# Impossible to find the combination
if ( sum ! = n):
print ( "Impossible" )
# Possible solution is stored in A[]
else :
for i in range ( 0 , k, 1 ):
print (A[i], end = ' ' )
# Driver code if __name__ = = '__main__' :
n = 12
k = 6
FindAllElements(n, k)
# This code is contributed by # Surendra_Gangwar |
// C# implementation of the above approach using System;
class GfG
{ // Function to print k numbers
// which are powers of two
// and whose sum is equal to n
public static void FindAllElements( int n, int k)
{
// Initialising the sum with k
int sum = k;
// Initialising an array A with k elements
// and filling all elements with 1
int [] A = new int [k];
for ( int i = 0; i < k; i++)
A[i] = 1;
for ( int i = k - 1; i >= 0; --i)
{
// Iterating A[] from k-1 to 0
while (sum + A[i] <= n)
{
// Update sum and A[i]
// till sum + A[i] is less than equal to n
sum += A[i];
A[i] *= 2;
}
}
// Impossible to find the combination
if (sum != n)
{
Console.Write( "Impossible" );
}
// Possible solution is stored in A[]
else
{
for ( int i = 0; i < k; ++i)
Console.Write(A[i] + " " );
}
}
// Driver code
public static void Main(String []args)
{
int n = 12;
int k = 6;
FindAllElements(n, k);
}
} // This code contributed by Rajput-Ji |
<?php // PHP implementation of the above approach // Function to print k numbers which are // powers of two and whose sum is equal to n function FindAllElements( $n , $k )
{ // Initialising the sum with k
$sum = $k ;
// Initialising an array A with k elements
// and filling all elements with 1
$A = array_fill (0, $k , 1) ;
for ( $i = $k - 1; $i >= 0; -- $i )
{
// Iterating A[] from k-1 to 0
while ( $sum + $A [ $i ] <= $n )
{
// Update sum and A[i] till
// sum + A[i] is less than equal to n
$sum += $A [ $i ];
$A [ $i ] *= 2;
}
}
// Impossible to find the combination
if ( $sum != $n )
{
echo "Impossible" ;
}
// Possible solution is stored in A[]
else
{
for ( $i = 0; $i < $k ; ++ $i )
echo $A [ $i ], ' ' ;
}
} // Driver code $n = 12;
$k = 6;
FindAllElements( $n , $k );
// This code is contributed by Ryuga ?> |
<script> // Javascript implementation of the above approach // Function to print k numbers which are powers of two // and whose sum is equal to n function FindAllElements( n, k)
{ // Initialising the sum with k
let sum = k;
// Initialising an array A with k elements
// and filling all elements with 1
let A = new Array(k).fill(1);
for (let i = k - 1; i >= 0; --i) {
// Iterating A[] from k-1 to 0
while (sum + A[i] <= n) {
// Update sum and A[i]
// till sum + A[i] is less than equal to n
sum += A[i];
A[i] *= 2;
}
}
// Impossible to find the combination
if (sum != n) {
document.write( "Impossible" );
}
// Possible solution is stored in A[]
else {
for (let i = 0; i < k; ++i)
document.write(A[i] + " " );
}
} // Driver Code let n = 12; let k = 6; FindAllElements(n, k); </script> |
1 1 1 1 4 4
Complexity Analysis:
- Time Complexity: O(k*log2(n-k))
- Auxiliary Space: O(k), since k extra space has been taken.