Python | Tuple XOR operation

Sometimes, while working with records, we can have a problem in which we may need to perform mathematical bitwise XOR operation across tuples. This problem can occur in day-day programming. Let’s discuss certain ways in which this task can be performed. 

Method #1: Using zip() + generator expression The combination of above functions can be used to perform this task. In this, we perform the task of XOR using generator expression and mapping index of each tuple is done by zip(). 

The original tuple 1 : (10, 4, 6, 9)
The original tuple 2 : (5, 2, 3, 3)
The XOR tuple : (15, 6, 5, 10)

Time complexity: O(n), where n is the length of the tuples. The XOR operation between two elements takes O(1) time and is performed n times, so the overall time complexity is O(n).
Auxiliary Space: O(n), where n is the length of the result tuple. The generator expression creates a new tuple with the XORed elements, so the space complexity is proportional to the size of the result tuple.

Method #2: Using map() + xor The combination of above functionalities can also perform this task. In this, we perform the task of extending logic of XOR using xor and mapping is done by map(). 

The original tuple 1 : (10, 4, 6, 9)
The original tuple 2 : (5, 2, 3, 3)
The XOR tuple : (15, 6, 5, 10)

Time complexity: O(n), where n is the length of the tuples. This is because the map() function and the xor operator iterate through the tuples once.
Auxiliary space: O(n), where n is the length of the tuples. This is because the tuple created by the map() function is of the same length as the input tuples.

Method #3 : Using numpy

Note: install numpy module using command “pip install numpy”

Output:

The original tuple 1 : (10, 4, 6, 9)
The original tuple 2 : (5, 2, 3, 3)
The XOR tuple : (15, 6, 5, 10)
 

Time complexity: O(n)
Auxiliary Space: O(n)

Method #4 : Using for loops

The original tuple 1 : (10, 4, 6, 9)
The original tuple 2 : (5, 2, 3, 3)
The XOR tuple : (15, 6, 5, 10)

Time complexity: O(n)
Auxiliary Space: O(n)

Method 5: Using List Comprehension

Use list comprehension to iterate over the elements of both tuples and perform the XOR operation. The resulting list can then be converted to a tuple.

Below is the implementation of the above idea:

The original tuple 1 : (10, 4, 6, 9)
The original tuple 2 : (5, 2, 3, 3)
The XOR tuple : (15, 6, 5, 10)

Time complexity: O(n), where n is the length of the tuples test_tup1 and test_tup2.
Auxiliary Space: O(n)

Method #6: Using itertools.starmap() + operator.xor()

The itertools.starmap() function applies a function to a sequence of argument tuples, and operator.xor() function returns the bitwise XOR of two integers.

The XOR tuple : (15, 6, 5, 10)

Time complexity: O(n), where n is the length of the tuples test_tup1 and test_tup2.
Auxiliary Space: O(n)

Method #7:Using the pandas module

• Import the pandas module and initialize two tuples.
• Create two data frames using the pandas.DataFrame() function, one for each tuple.
• Use the pandas.DataFrame.diff() function to calculate the difference between the two data frames.
• Use the pandas.DataFrame.gt() function to create a boolean mask indicating where the values in the first data frame are greater than those in the second data frame.
• Use the pandas.DataFrame.where() function to apply the boolean mask to the results of step 3.
• Use the pandas.DataFrame.fillna() function to fill any NaN values in the resulting data frame with False.
• Convert the resulting data frame to a list of lists using the pandas.DataFrame.values.tolist() function.

Output-

The original tuple 1 : (10, 4, 6, 9)
The original tuple 2 : (5, 2, 3, 3)
The XOR tuple : (15, 6, 5, 10)

The time complexity of this solution is O(n), where n is the length of the tuple.
The space complexity of this solution is O(n), as we are creating a new tuple of length n to store the result.