Skip to content
Related Articles

Related Articles

Represent N as the sum of exactly K powers of two | Set 3
  • Difficulty Level : Medium
  • Last Updated : 03 Feb, 2021

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. Otherwise, print “Impossible”. If multiple answers exist, print any.

Examples:

Input: N = 5, K = 2
Output: 4 1
Explanation:
The only way of representing N as K numbers that are powers of 2 is {4, 1}.

Input: N = 7, K = 4
Output: 4 1 1 1
Explanation: 
The possible ways of representing N as K numbers that are powers of 2 are {4, 1, 1, 1} and {2, 2, 2, 1}.

Priority Queue based Approach: Refer tothis article to solve the problem using Priority Queue.

Recursive Approach: Refer to thisarticle to solve the problem using Recursion.

Alternate Approach: The idea is to use the Greedy Approach to solve this problem. Below are the steps:



  • Initialize an integer, say num = 31, and a vector of integers, say res, to store the K numbers which are powers of 2.
  • Check if the number of bits in N is greater than K or if N is less than K, then print “Impossible”.
  • Iterate while num ≥ 0 and K > 0:
    • Check if N – 2num is less than K – 1. If found to be true, then decrement num by one and continue.
    • Otherwise, decrement K by one, and N by 2num and push num into the vector res.
  • Finally, print the vector res.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find K numbers with
// sum N that are powers of 2
void nAsKPowersOfTwo(int N, int K)
{
    // Count the number of set bits
    int x = __builtin_popcount(N);
 
    // Not-possible condition
    if (K < x || K > N) {
        cout << "Impossible";
        return;
    }
 
    int num = 31;
 
    // To store K numbers
    // which are powers of 2
    vector<int> res;
 
    // Traverse while num >= 0
    while (num >= 0 && K) {
 
        // Calculate current bit value
        int val = pow(2, num);
 
        // Check if remaining N
        // can be reprsented as
        // K-1 numbers that are
        // power of 2
        if (N - val < K - 1) {
 
            // Decrement num by one
            --num;
            continue;
        }
 
        // Decrement K by one
        --K;
 
        // Decrement N by val
        N -= val;
 
        // Push the num in the
        // vector res
        res.push_back(num);
    }
 
    // Print the vector res
    for (auto x : res)
        cout << pow(2, x) << " ";
}
 
// Driver Code
int main()
{
    // Given N & K
    int N = 7, K = 4;
 
    // Function Call
    nAsKPowersOfTwo(N, K);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach
import java.util.*;
class GFG{
 
// Function to find K numbers with
// sum N that are powers of 2
static void nAsKPowersOfTwo(int N, int K)
{
   
    // Count the number of set bits
    int x = Integer.bitCount(N);
 
    // Not-possible condition
    if (K < x || K > N)
    {
        System.out.print("Impossible");
        return;
    }
 
    int num = 31;
 
    // To store K numbers
    // which are powers of 2
    Vector<Integer> res = new Vector<Integer>();
 
    // Traverse while num >= 0
    while (num >= 0 && K > 0)
    {
 
        // Calculate current bit value
        int val = (int) Math.pow(2, num);
 
        // Check if remaining N
        // can be reprsented as
        // K-1 numbers that are
        // power of 2
        if (N - val < K - 1)
        {
 
            // Decrement num by one
            --num;
            continue;
        }
 
        // Decrement K by one
        --K;
 
        // Decrement N by val
        N -= val;
 
        // Push the num in the
        // vector res
        res.add(num);
    }
 
    // Print the vector res
    for (int i : res)
        System.out.print((int)Math.pow(2, i)+ " ");
}
 
// Driver Code
public static void main(String[] args)
{
    // Given N & K
    int N = 7, K = 4;
 
    // Function Call
    nAsKPowersOfTwo(N, K);
}
}
 
// This code is contributed by 29AjayKumar

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for the above approach
 
# Function to find K numbers with
# sum N that are powers of 2
def nAsKPowersOfTwo(N, K):
     
    # Count the number of set bits
    x = bin(N).count('1')
 
    # Not-possible condition
    if (K < x or K > N):
        cout << "Impossible"
        return
    num = 31
 
    # To store K numbers
    # which are powers of 2
    res = []
 
    # Traverse while num >= 0
    while (num >= 0 and K):
 
        # Calculate current bit value
        val = pow(2, num)
 
        # Check if remaining N
        # can be reprsented as
        # K-1 numbers that are
        # power of 2
        if (N - val < K - 1):
 
            # Decrement num by one
            num -= 1
            continue
 
        # Decrement K by one
        K -= 1
 
        # Decrement N by val
        N -= val
 
        # Push the num in the
        # vector res
        res.append(num)
 
    # Prthe vector res
    for x in res:
        print(pow(2, x), end = " ")
 
# Driver Code
if __name__ == '__main__':
     
    # Given N & K
    N, K = 7, 4
 
    # Function Call
    nAsKPowersOfTwo(N, K)
 
# This code is contributed mohit kumar 29.

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG{
 
// Function to find K numbers with
// sum N that are powers of 2
static void nAsKPowersOfTwo(int N, int K)
{
   
    // Count the number of set bits
    int x = countSetBits(N);
 
    // Not-possible condition
    if (K < x || K > N)
    {
        Console.Write("Impossible");
        return;
    }
 
    int num = 31;
 
    // To store K numbers
    // which are powers of 2
    List<int> res = new List<int>();
 
    // Traverse while num >= 0
    while (num >= 0 && K > 0)
    {
 
        // Calculate current bit value
        int val = (int) Math.Pow(2, num);
 
        // Check if remaining N
        // can be reprsented as
        // K-1 numbers that are
        // power of 2
        if (N - val < K - 1)
        {
 
            // Decrement num by one
            --num;
            continue;
        }
 
        // Decrement K by one
        --K;
 
        // Decrement N by val
        N -= val;
 
        // Push the num in the
        // vector res
        res.Add(num);
    }
 
    // Print the vector res
    foreach (int i in res)
        Console.Write((int)Math.Pow(2, i)+ " ");
}
static int countSetBits(long x)
{
    int setBits = 0;
    while (x != 0)
    {
        x = x & (x - 1);
        setBits++;
    }
    return setBits;
}
   
// Driver Code
public static void Main(String[] args)
{
    // Given N & K
    int N = 7, K = 4;
 
    // Function Call
    nAsKPowersOfTwo(N, K);
}
}
 
// This code is contributed by shikhasingrajput

chevron_right


 
 

Output: 

4 1 1 1

 

Time Complexity: O(32)
Auxiliary Space: O(1) 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :