Construct a List using the given Q XOR queries

 Given a list S that initially contains a single value 0. Below are the Q queries of the following types:

• 0 X: Insert X in the list
• 1 X: For every element A in S, replace it by A XOR X.

The task is to print all the element in the list in increasing order after performing the given Q queries.

Examples:

Input: Q[][] = { {0, 6}, {0, 3}, {0, 2}, {1, 4}, {1, 5} }
Output: 1 2 3 7
Explanation:
[0] (initial value)
[0 6] (add 6 to list)
[0 6 3] (add 3 to list)
[0 6 3 2] (add 2 to list)
[4 2 7 6] (XOR each element by 4)
[1 7 2 3] (XOR each element by 5)
Thus sorted order after performing queries is [1 2 3 7]

Input: Q[][]= {{0, 2}, {1, 3}, {0, 5} }
Output: 1 3 5
Explanation:
[0] (initial value)
[0 2] (add 2 to list)
[3 1] (XOR each element by 3)
[3 1 5] (add 5 to list)
Thus sorted order after performing queries is [1 3 5]

Naive Approach: The simplest approach to solve the problem is:

1. Initialize a list with 0 then traverse for each query and do the following:
   • For query type 0 add given value in the list.
   • For query type 1 traverse list and update every element with their respective Bitwise XOR with value.
2. After all the queries performed, print the final list in increasing order.

Time Complexity: O(N*Q+Q*log(Q)), where N is the length of the list and Q is the number of queries
Auxiliary Space: O(1)

Efficient Approach: It is much easier to process the numbers in reverse order by keeping track of the cumulative Bitwise XOR working from right to left. Follow the steps below to solve the problem:

1. Initialize a variable xor with 0.
2. Iterate over the query array from right to left, add xor^value to the list while query type is 0 otherwise update xor with xor^value.
3. After traversing query add xor to the list and sort the final list.
4. Print the final list after the above operations.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
#define N 5
#define M 2

// Function to return required list
// after performing all the queries
list<int> ConstructList(int Q[N][M])
{

    // Store cumulative Bitwise XOR
    int xr = 0;

    // Initialize final list to return
    list<int> ans;

    // Perform each query
    for (int i = N - 1; i >= 0; i--)
    {
        if (Q[i][0] == 0)
            ans.push_back(Q[i][1] ^ xr);
        else
            xr ^= Q[i][1];
    }

    // The initial value of 0
    ans.push_back(xr);

    // Sort the list
    ans.sort();

    // Return final list
    return ans;
}

// Driver Code
int main()
{
    // Given Queries
    int Q[N][M] = {{ 0, 6 }, { 0, 3 },
                   { 0, 2 }, { 1, 4 },
                   { 1, 5 }};

    // Function Call
    list<int> ans = ConstructList(Q);
    for (auto it = ans.begin(); it != ans.end(); ++it)
        cout << ' ' << *it;
}

// This code is contributed by gauravrajput1

Java

// Java program for the above approach
import java.util.*;

class GFG {

    // Function to return required list
    // after performing all the queries
    static List<Integer> ConstructList(int[][] Q)
    {

        // Store cumulative Bitwise XOR
        int xor = 0;

        // Initialize final list to return
        List<Integer> ans = new ArrayList<>();

        // Perform each query
        for (int i = Q.length - 1; i >= 0; i--) {

            if (Q[i][0] == 0)
                ans.add(Q[i][1] ^ xor);

            else
                xor ^= Q[i][1];
        }

        // The initial value of 0
        ans.add(xor);

        // Sort the list
        Collections.sort(ans);

        // Return final list
        return ans;
    }

    // Driver Code
    public static void main(String[] args)
    {
        // Given Queries
        int[][] Q = {
            { 0, 6 }, { 0, 3 }, { 0, 2 },
            { 1, 4 }, { 1, 5 }
        };

        // Function Call
        System.out.println(ConstructList(Q));
    }
}

Python3

# Python3 program for the above approach

# Function to return required list
# after performing all the queries
def ConstructList(Q):

    # Store cumulative Bitwise XOR
    xor = 0

    # Initialize final list to return
    ans = []

    # Perform each query
    for i in range(len(Q) - 1, -1, -1):
        if(Q[i][0] == 0):
            ans.append(Q[i][1] ^ xor)

        else:
            xor ^= Q[i][1]

    # The initial value of 0
    ans.append(xor)

    # Sort the list
    ans.sort()

    # Return final list
    return ans

# Driver Code

# Given Queries
Q = [ [0, 6], [0, 3],
      [0, 2], [1, 4],
      [1, 5] ]

# Function call
print(ConstructList(Q))

# This code is contributed by Shivam Singh

C#

// C# program for the above approach
using System;
using System.Collections.Generic;

class GFG{

    // Function to return required list
    // after performing all the queries
    static List<int> ConstructList(int[,] Q)
    {

        // Store cumulative Bitwise XOR
        int xor = 0;

        // Initialize readonly list to return
        List<int> ans = new List<int>();

        // Perform each query
        for (int i = Q.GetLength(0) - 1; i >= 0; i--)
        {
            if (Q[i, 0] == 0)
                ans.Add(Q[i, 1] ^ xor);

            else
                xor ^= Q[i, 1];
        }

        // The initial value of 0
        ans.Add(xor);

        // Sort the list
        ans.Sort();

        // Return readonly list
        return ans;
    }

    // Driver Code
    public static void Main(String[] args)
    {
        // Given Queries
        int[,] Q = {{ 0, 6 }, { 0, 3 }, { 0, 2 },
                    { 1, 4 }, { 1, 5 }};

        // Function Call
        foreach( int i in ConstructList(Q))
            Console.Write(i + ", ");
    }
}

// This code is contributed by Princi Singh

Javascript

<script>
// Javascript program for the above approach
var N = 5
var M = 2

// Function to return required list
// after performing all the queries
function ConstructList(Q)
{

    // Store cumulative Bitwise XOR
    var xr = 0;

    // Initialize final list to return
    var ans = [];

    // Perform each query
    for (var i = N - 1; i >= 0; i--)
    {
        if (Q[i][0] == 0)
            ans.push(Q[i][1] ^ xr);
        else
            xr ^= Q[i][1];
    }

    // The initial value of 0
    ans.push(xr);

    // Sort the list
    ans.sort((a,b)=>a-b);

    // Return final list
    return ans;
}

// Driver Code
// Given Queries
var Q = [[ 0, 6 ], [ 0, 3 ],
               [ 0, 2 ], [ 1, 4 ],
               [ 1, 5 ]];
// Function Call
var ans = ConstructList(Q);
ans.forEach(element => {
    document.write(" "+element);
});

// This code is contributed by famously.
</script>

Output:

[1, 2, 3, 7]

Time Complexity: O(Q * log(Q)), where Q is the number of queries.
Auxiliary Space: O(N), where N is the number of elements in the resultant list.