How to efficiently apply XOR to two integer arrays? - algorithm

Question

I have two arrays as follows:
A = [1,2,35,4,32,1,2,56,43,2,21]
B = [1,2,35,4,32,1,2,56,43,45,1]
As we can see that A and B has initial subsequence same till element 43. My end goal is to calculate the XOR of last uncommon elements of both of these sequences. Here, my goal is to find XOR of {2,21,45,1}.
Currently, my approach is to store running XOR of both of these arrays in two separate Arrays (say, RESA[], & RESB[]) and then when ever I am asked to find the the XOR of A[0-10] & B[0-9], I just quickly perform a single XOR operation as follows:
RESA[10] ^ RESB[9]
This works because while XORing, common elements cancels out.
My problem here is, what if in every query a threshold T is passed. For example, in this case, if the threshold passed is 32 the I have to filter elements that are less than 32 in both A and B and then apply XORing of all such elements. This definitely increases the complexity, and I cannot apply my earlier logic of keeping running XORs of elements.
Please let me know if you have any ideas on how to leverage XOR properties to come up with a constant time approach as before when there was no thresholds.

Answer 1

You have already worked you that you can find the XOR of the uncommon elements by computing the XOR of every element in the two arrays.
XOR is a commutative and associative operator so we can reorder the arrays in any way we like and still have the same total XOR.
In particular, we can reverse sort each array, and then compute the running XOR of each sorted array.
With this preprocessing we can now compute the XOR of all elements above a threshold by using binary search on each sorted array to find how many elements above T, followed by a lookup into the running XOR array.
This gives an O(logn) complexity for each query.
Extension
The above answer assumes that the query is just the threshold 32: i.e. the start is always 0, and the end is always the length of each sequence. (I assume this because the question says the final goal is to compute the XOR of all uncommon elements.)
If the query also consisted of the start and end of the region to be XORed I would suggest a different approach that requires more storage (because it requires all queries to be buffered and sorted):
Sort all the queries by threshold
Maintain a segment tree of the XOR for each sequence, intialized to 0.
Add the values into the sequences in decreasing order, and perform the queries as soon as all values above their threshold have been inserted.
For example, the segment tree for a sequence C=[1,2,35,4,32,1,2,56] would contain:
1
2
35
4
32
1
2
56
1^2
35^4
32^1
2^56
1^2^35^4
32^1^2^56
1^2^35^4^32^1^2^56
Once we have these values we can compute the XOR of any range using log(n) steps. For example, suppose we wanted to compute the XOR of C[1:3] = [2,35,4]. We can do this by xoring 2 with 35^4.