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

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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));
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.