# Represent N as the sum of exactly K powers of two | Set 3

• Difficulty Level : Medium
• Last Updated : 23 Aug, 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 to this article to solve the problem using Priority Queue.

Recursive Approach: Refer to this article 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, decrease 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++

 `// C++ program for the above approach` `#include ``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 represented 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);``}`

## Java

 `// 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 res = ``new` `Vector();` `    ``// 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 represented 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`

## Python3

 `# 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 represented 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)` `    ``# Print 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.`

## C#

 `// 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 represented 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`

## Javascript

 ``

Output:

`4 1 1 1`

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

My Personal Notes arrow_drop_up