Open In App
Related Articles

Python | Elementwise AND in tuples

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Sometimes, while working with records, we can have a problem in which we may need to perform mathematical bitwise AND 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 AND using generator expression and mapping index of each tuple is done by zip(). 

Python3

# Python3 code to demonstrate working of
# Elementwise AND in tuples
# using zip() + generator expression
 
# initialize tuples
test_tup1 = (10, 4, 6, 9)
test_tup2 = (5, 2, 3, 3)
 
# printing original tuples
print("The original tuple 1 : " + str(test_tup1))
print("The original tuple 2 : " + str(test_tup2))
 
# Elementwise AND in tuples
# using zip() + generator expression
res = tuple(ele1 & ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
 
# printing result
print("The AND tuple : " + str(res))

                    
Output : 
The original tuple 1 : (10, 4, 6, 9)
The original tuple 2 : (5, 2, 3, 3)
The AND tuple : (0, 0, 2, 1)

Time Complexity: O(n)
Auxiliary Space: O(1)

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

Python3

# Python3 code to demonstrate working of
# Elementwise AND in tuples
# using map() + iand
from operator import iand
 
# initialize tuples
test_tup1 = (10, 4, 6, 9)
test_tup2 = (5, 2, 3, 3)
 
# printing original tuples
print("The original tuple 1 : " + str(test_tup1))
print("The original tuple 2 : " + str(test_tup2))
 
# Elementwise AND in tuples
# using map() + iand
res = tuple(map(iand, test_tup1, test_tup2))
 
# printing result
print("The AND tuple : " + str(res))

                    
Output : 
The original tuple 1 : (10, 4, 6, 9)
The original tuple 2 : (5, 2, 3, 3)
The AND tuple : (0, 0, 2, 1)

Method #3: Using numpy.bitwise_and
This approach uses the numpy library to perform the bitwise AND operation on the tuples element-wise. It converts the tuples to numpy arrays, and then uses the numpy.bitwise_and function to perform the operation.

Python3

# Python3 code to demonstrate working of
# Elementwise AND in tuples
# using numpy.bitwise_and
 
import numpy as np
 
# initialize tuples
test_tup1 = (10, 4, 6, 9)
test_tup2 = (5, 2, 3, 3)
 
# printing original tuples
print("The original tuple 1 : " + str(test_tup1))
print("The original tuple 2 : " + str(test_tup2))
 
# Elementwise AND in tuples
# using numpy.bitwise_and
res = tuple(np.bitwise_and(np.array(test_tup1), np.array(test_tup2)))
 
# printing result
print("The AND tuple : " + str(res))
#This code is contributed by Edula Vinay Kumar Reddy

                    

Output:

The original tuple 1 : (10, 4, 6, 9)
The original tuple 2 : (5, 2, 3, 3)
The AND tuple : (0, 0, 2, 1)

This approach has time complexity of O(n) as it iterates through the tuples once, and the auxiliary space is O(n) as it creates 2 numpy arrays with n elements each.

Method 4 :  using a list comprehension and bitwise operators.

 steps for this approach:

  1. Initialize the input tuples.
  2. Use a list comprehension to perform elementwise AND operation on each pair of corresponding elements in the tuples using the bitwise & operator. The zip function is used to pair corresponding elements from both tuples.
  3. Convert the resulting list to a tuple using the tuple() function.
  4. Print the resulting tuple.

Python3

# Initialize input tuples
test_tup1 = (10, 4, 6, 9)
test_tup2 = (5, 2, 3, 3)
 
# Perform elementwise AND operation using a list comprehension and bitwise &
res = tuple(test_tup1[i] & test_tup2[i] for i in range(len(test_tup1)))
 
# Print the resulting tuple
print("The AND tuple: " + str(res))

                    

Output
The AND tuple: (0, 0, 2, 1)

Time complexity: O(n), where n is the length of the input tuple.

Auxiliary space: O(n), where n is the length of the input tuple, because we create a list to store the result of the elementwise AND operation. .

METHOD 5:Using For loop and Bitwise AND operator

APPROACH:

The given problem is to find the elementwise AND of corresponding elements in two tuples test_tup1 and test_tup2, and return a new tuple with the results. To solve this problem, we can use a for loop to iterate over the indices of the tuples, and use the bitwise AND operator to get the AND of the corresponding elements in the tuples. We append the results to a new tuple and_tuple, and finally return this tuple as the output. The time and space complexity of this algorithm is O(n), where n is the length of the tuples.

ALGORITHM:

1.Initialize an empty tuple and_tuple.
2.Use a for loop to iterate over the indices of test_tup1.
3.For each index i, use the bitwise AND operator to get the AND of the corresponding elements in test_tup1 and test_tup2, and append the result to and_tuple.
4.Convert the resulting list and_tuple to a tuple using the tuple() constructor.
5.Print the resulting tuple and_tuple.

Python3

test_tup1 = (10, 4, 6, 9)
test_tup2 = (5, 2, 3, 3)
 
and_tuple = ()
for i in range(len(test_tup1)):
    and_tuple += ((test_tup1[i] & test_tup2[i]),)
 
print("The AND tuple:", and_tuple)

                    

Output
The AND tuple: (0, 0, 2, 1)

Time Complexity: O(n), where n is the length of the tuples test_tup1 and test_tup2. The for loop runs n times to iterate over the indices of the tuples.

Space Complexity: O(n), where n is the length of the tuples test_tup1 and test_tup2. The space used is for the tuple and_tuple, which has n elements.



Last Updated : 26 Apr, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads