# Represent n as the sum of exactly k powers of two | Set 2

Last Updated : 13 Sep, 2022

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++

 `// C++ implementation of the above approach` `#include ` `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

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

## Python3

 `# 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#

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

 `= 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` `?>`

## Javascript

 ``

Output

`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.

Article Tags :
Practice Tags :