Given an integer **N**, the task is to find the numbers which when added after being raised to the Power of 2 gives the integer **N**.

**Examples:**

Input:N = 12345Output:0, 3, 4, 5, 12, 13Explanation:

12345 = 2^0 + 2^3 + 2^4 + 2^5 + 2^12 + 2^13

Input:N = 10000Output:4, 8, 9, 10, 13Explanation:

10000 = 2^4 + 2^8 + 2^9 + 2^10 + 2^13

**Approach:**

- Since every number can be expressed as sum of powers of 2, the task is to print every
**i**when i^{th}bit is set in the binary representation of**N**. **Illustration:**

(29)_{10}= (11101)_{2}

Thus, in 29, {0, 2, 3, 4} are the indices of the set bits.

2^{0}+ 2^{2}+ 2^{3}+ 2^{4}

= 1 + 4 + 8 + 16

= 29- In order to check if i
^{th}bit is set, we only need to check:if( N & (1 << i) ) == 1

**Illustration:**

(29)_{10}= (11101)_{2}

0^{th}bit: 11101 & 1 = 1

1^{st}bit: 11101 & 10 = 0

2^{nd}bit: 11101 & 100 = 1

3^{rd}bit: 11101 & 1000 = 1

4^{th}bit: 11101 & 10000 = 1

Below is the implementation of the above approach.

## C++

`// C++ Program to split N` `// into numbers which when` `// added after being raised` `// to the power of 2 gives N` ` ` `#include <bits/stdc++.h>` `using` `namespace` `std;` ` ` `// Function to print the numbers` `// which raised to power of 2` `// adds up to N` `void` `PowerOfTwo(` `long` `long` `N)` `{` ` ` `for` `(` `int` `i = 0; i < 64; i++) {` ` ` `long` `long` `x = 1;` ` ` ` ` `// Checking if i-th bit is` ` ` `// set in N or not by` ` ` `// shifting 1 i bits to` ` ` `// the left and performing` ` ` `// AND with N` ` ` `if` `(N & (x << i))` ` ` `cout << i << ` `" "` `;` ` ` `}` `}` ` ` `// Driver Code` `int` `main()` `{` ` ` ` ` `long` `long` `N = 12345;` ` ` `PowerOfTwo(N);` ` ` ` ` `return` `0;` `}` |

## Java

`// Java Program to split N` `// into numbers which when` `// added after being raised` `// to the power of 2 gives N` `class` `GFG{` ` ` `// Function to print the numbers` `// which raised to power of 2` `// adds up to N` `static` `void` `PowerOfTwo(` `long` `N)` `{` ` ` `for` `(` `int` `i = ` `0` `; i < ` `64` `; i++) ` ` ` `{` ` ` `long` `x = ` `1` `;` ` ` ` ` `// Checking if i-th bit is` ` ` `// set in N or not by` ` ` `// shifting 1 i bits to` ` ` `// the left and performing` ` ` `// AND with N` ` ` `if` `((N & (x << i)) > ` `0` `)` ` ` `System.out.print(i + ` `" "` `);` ` ` `}` `}` ` ` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` `long` `N = ` `12345` `;` ` ` `PowerOfTwo(N);` `}` `}` ` ` `// This code is contributed by Amit Katiyar` |

## Python3

`# Python3 program to split N` `# into numbers which when` `# added after being raised` `# to the power of 2 gives N` ` ` `# Function to print the numbers` `# which raised to power of 2` `# adds up to N` `def` `PowerOfTwo(N):` ` ` ` ` `for` `i ` `in` `range` `(` `0` `, ` `64` `): ` ` ` `x ` `=` `1` ` ` ` ` `# Checking if i-th bit is` ` ` `# set in N or not by` ` ` `# shifting 1 i bits to` ` ` `# the left and performing` ` ` `# AND with N` ` ` `if` `(N & (x << i)) > ` `0` `:` ` ` `print` `(i, end ` `=` `" "` `)` ` ` `# Driver Code ` `if` `__name__ ` `=` `=` `"__main__"` `: ` ` ` ` ` `# Given number` ` ` `N ` `=` `12345` `;` ` ` ` ` `# Function call` ` ` `PowerOfTwo(N)` ` ` `# This code is contributed by rock_cool` |

## C#

`// C# Program to split N` `// into numbers which when` `// added after being raised` `// to the power of 2 gives N` `using` `System;` `class` `GFG{` ` ` `// Function to print the numbers` `// which raised to power of 2` `// adds up to N` `static` `void` `PowerOfTwo(` `long` `N)` `{` ` ` `for` `(` `int` `i = 0; i < 64; i++) ` ` ` `{` ` ` `long` `x = 1;` ` ` ` ` `// Checking if i-th bit is` ` ` `// set in N or not by` ` ` `// shifting 1 i bits to` ` ` `// the left and performing` ` ` `// AND with N` ` ` `if` `((N & (x << i)) > 0)` ` ` `Console.Write(i + ` `" "` `);` ` ` `}` `}` ` ` `// Driver Code` `public` `static` `void` `Main()` `{` ` ` `long` `N = 12345;` ` ` `PowerOfTwo(N);` `}` `}` ` ` `// This code is contributed by Nidhi_biet` |

**Output:**

0 3 4 5 12 13

**Time Complexity:** O(log N)**Space Complexity:** O(1)

For an alternative approach, refer to Powers of 2 to required sum