 GeeksforGeeks App
Open App Browser
Continue

# Python | Elementwise AND in tuples

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.

My Personal Notes arrow_drop_up