Array que contiene potencia de 2 cuyo XOR y Suma de elementos es igual a X

Dado un entero X. La tarea es encontrar y devolver la array que contiene potencias de 2 y el xor de la array es X.
Ejemplos: 
 

Entrada: X = 20 
Salida: 16 4
Entrada: X = 15 
Salida: 1 2 4 8 
 

Planteamiento: La respuesta está en la representación binaria del número X.
Dado que en la potencia de 2, solo hay un bit establecido. Si hay dos potencias distintas de 2 presentes, entonces el xor será la suma de ambos números.
De manera similar, si se tomará xor de toda la array, entonces debería ser igual a X y esa será la representación binaria de ese número.
Dado que hay un conjunto de bits distinto en cada potencia de 2 , el xor y la suma de los elementos de la array serán los mismos.
A continuación se muestra la implementación del enfoque anterior: 
 

// C++ implementation of the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the required array
vector<long> getArray(int n)
{
    vector<long> ans;
 
    // Store the power of 2
    long p2 = 1;
 
    // while n is greater than 0
    while (n > 0) {
         
        // if there is 1 in binary
        // representation
        if (n & 1)
            ans.push_back(p2);
 
        // Divide n by 2
        // Multiply p2 by 2
        n >>= 1;
        p2 *= 2;
    }
 
    return ans;
}
 
// Driver code
int main()
{
    long n = 15;
 
    // Get the answer
    vector<long> ans = getArray(n);
 
    // Printing the array
    for(int i : ans)
        cout << i << " ";
 
    return 0;
}

// Java implementation implementation
// of the above approach
import java.util.*;
class GFG
{
 
// Function to return the required array
static Vector<Long> getArray(int n)
{
    Vector<Long> ans = new Vector<Long>();
 
    // Store the power of 2
    long p2 = 1;
 
    // while n is greater than 0
    while (n > 0)
    {
         
        // if there is 1 in binary
        // representation
        if (n % 2 == 1)
            ans.add(p2);
 
        // Divide n by 2
        // Multiply p2 by 2
        n >>= 1;
        p2 *= 2;
    }
    return ans;
}
 
// Driver code
public static void main(String[] args)
{
    int n = 15;
 
    // Get the answer
    Vector<Long> ans = getArray(n);
 
    // Printing the array
    for(Long i : ans)
        System.out.print(i + " ");
}
}
 
// This code is contributed by 29AjayKumar

# Python3 implementation of the above approach
 
# Function to return the required array
def getArray(n) :
 
    ans = [];
 
    # Store the power of 2
    p2 = 1;
 
    # while n is greater than 0
    while (n > 0) :
         
        # if there is 1 in binary
        # representation
        if (n & 1) :
            ans.append(p2);
 
        # Divide n by 2
        # Multiply p2 by 2
        n >>= 1;
        p2 *= 2;
 
    return ans;
 
# Driver code
if __name__ == "__main__" :
 
    n = 15;
 
    # Get the answer
    ans = getArray(n);
 
    # Printing the array
    for i in ans :
        print(i, end = " ");
 
# This code is contributed by AnkitRai01

// C# implementation of the approach
using System;
using System.Collections.Generic;
 
class GFG
{
 
// Function to return the required array
static List<long> getArray(int n)
{
    List<long> ans = new List<long>();
 
    // Store the power of 2
    long p2 = 1;
 
    // while n is greater than 0
    while (n > 0)
    {
         
        // if there is 1 in binary
        // representation
        if (n % 2 == 1)
            ans.Add(p2);
 
        // Divide n by 2
        // Multiply p2 by 2
        n >>= 1;
        p2 *= 2;
    }
    return ans;
}
 
// Driver code
public static void Main(String[] args)
{
    int n = 15;
 
    // Get the answer
    List<long> ans = getArray(n);
 
    // Printing the array
    foreach(long i in ans)
        Console.Write(i + " ");
}
}
 
// This code is contributed by Princi Singh

<script>
// Javascript implementation of the above approach
 
// Function to return the required array
function getArray(n)
{
    let ans = [];
 
    // Store the power of 2
    let p2 = 1;
 
    // while n is greater than 0
    while (n > 0) {
         
        // if there is 1 in binary
        // representation
        if (n & 1)
            ans.push(p2);
 
        // Divide n by 2
        // Multiply p2 by 2
        n >>= 1;
        p2 *= 2;
    }
 
    return ans;
}
 
// Driver code
    let n = 15;
 
    // Get the answer
    let ans = getArray(n);
 
    // Printing the array
    for(let i = 0; i < ans.length; i++)
        document.write(ans[i] + " ");
 
</script>

1 2 4 8 

Complejidad de tiempo: O(n)

Espacio Auxiliar: O(n)