Open In App

Python – Modulo of tuple elements

Improve
Improve
Like Article
Like
Save
Share
Report

Sometimes, while working with records, we can have a problem in which we may need to perform a modulo of 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 the above functions can be used to perform this task. In this, we perform the task of modulo using generator expression and the mapping index of each tuple is done by zip(). 

Python3




# Python3 code to demonstrate working of
# Tuple modulo
# using zip() + generator expression
 
# Initialize tuples
test_tup1 = (10, 4, 5, 6)
test_tup2 = (5, 6, 7, 5)
 
# Printing original tuples
print("The original tuple 1 : " + str(test_tup1))
print("The original tuple 2 : " + str(test_tup2))
 
# Tuple modulo
# using zip() + generator expression
res = tuple(ele1 % ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
 
# Printing result
print("The modulus tuple : " + str(res))


Output : 

The original tuple 1 : (10, 4, 5, 6)
The original tuple 2 : (5, 6, 7, 5)
The modulus tuple : (0, 4, 5, 1)

Time complexity: O(n), where n is the length of the tuples.
Auxiliary space: O(n), as a new tuple is created to store the result.

Method #2: Using map() + mod

The combination of the above functionalities can also perform this task. In this, we perform the task of extending logic of modulus using mod and mapping is done by map(). 

Python3




# Python3 code to demonstrate working of
# Tuple modulo
# using map() + mod
from operator import mod
 
# initialize tuples
test_tup1 = (10, 4, 5, 6)
test_tup2 = (5, 6, 7, 5)
 
# printing original tuples
print("The original tuple 1 : " + str(test_tup1))
print("The original tuple 2 : " + str(test_tup2))
 
# Tuple modulo
# using map() + mod
res = tuple(map(mod, test_tup1, test_tup2))
 
# printing result
print("The modulus tuple : " + str(res))


Output : 

The original tuple 1 : (10, 4, 5, 6)
The original tuple 2 : (5, 6, 7, 5)
The modulus tuple : (0, 4, 5, 1)

Time complexity: O(n), where n is the size of the tuples. This is because the program only performs a single pass through the tuples to compute the element-wise modulus using the map() and mod() functions.
Auxiliary space: O(n), where n is the size of the tuples. 

Method #3: Using for loop 

Python3




# Python3 code to demonstrate working of
# Tuple modulo
 
# Initialize tuples
test_tup1 = (10, 4, 5, 6)
test_tup2 = (5, 6, 7, 5)
 
# Printing original tuples
print("The original tuple 1 : " + str(test_tup1))
print("The original tuple 2 : " + str(test_tup2))
 
# Tuple modulo
res=[]
for i in range(0,len(test_tup1)):
    res.append(test_tup1[i]%test_tup2[i])
res=tuple(res)
 
# Printing result
print("The modulus tuple : " + str(res))


Output

The original tuple 1 : (10, 4, 5, 6)
The original tuple 2 : (5, 6, 7, 5)
The modulus tuple : (0, 4, 5, 1)

Time complexity: O(n), where n is the length of the tuples. 
Auxiliary space: O(n)

Method #4: Using numpy

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

It provides a convenient way to perform element-wise mathematical operations on arrays and lists.

Python3




import numpy as np
 
# initialize tuples
test_tup1 = (10, 4, 5, 6)
test_tup2 = (5, 6, 7, 5)
 
# printing original tuples
print("The original tuple 1 : " + str(test_tup1))
print("The original tuple 2 : " + str(test_tup2))
 
# Tuple modulo using numpy
res = tuple(np.mod(test_tup1, test_tup2))
 
# printing result
print("The modulus tuple : " + str(res))
 
#This code is contributed by Edula Vinay Kumar Reddy


Output:

The original tuple 1 : (10, 4, 5, 6)
The original tuple 2 : (5, 6, 7, 5)
The modulus tuple : (0, 4, 5, 1)

Time complexity: O(n) where n is the size of a tuple.
Auxiliary Space: O(n) as we are creating a new tuple of the same size as the original tuple.

Method #5: Using the Recursive method

Algorithm:

  1. Define a function called modulo_tuple that takes two tuples t1 and t2 as input, along with an optional result tuple which is initially empty.
  2. Check if the first tuple t1 is empty. If it is, return the result tuple.
  3. Otherwise, recursively call the modulo_tuple function with the first element of t1 and t2 removed, and the modulo of the first elements of t1 and t2 appended to result.
  4. Initialize two tuples test_tup1 and test_tup2 with some values.
  5. Print the original tuples test_tup1 and test_tup2.
  6. Call the modulo_tuple function with test_tup1 and test_tup2 as arguments and store the result in a variable called result.
  7. Print the result tuple.

Python3




# Python3 code to demonstrate working of
# Tuple modulo
# using recursive method
def modulo_tuple(t1, t2, result=()):
    if not t1:
        return result
    return modulo_tuple(t1[1:], t2[1:], result + (t1[0] % t2[0],))
 
 
# initialize tuples
test_tup1 = (10, 4, 5, 6)
test_tup2 = (5, 6, 7, 5)
 
# printing original tuples
print("The original tuple 1 : " + str(test_tup1))
print("The original tuple 2 : " + str(test_tup2))
 
# Tuple modulo
result = modulo_tuple(test_tup1, test_tup2)
 
# printing result
print("The modulus tuple : " + str(result))
 
# this code contributed by tvsk


Output

The original tuple 1 : (10, 4, 5, 6)
The original tuple 2 : (5, 6, 7, 5)
The modulus tuple : (0, 4, 5, 1)

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

Method #6: Using itertools.starmap()

Algorithm:

  1. Import itertools module.
  2. Define two tuples test_tup1 and test_tup2.
  3. Using starmap() function, map the modulus operation with each element of both the tuples using lambda function and zip() function.
  4. Convert the resultant object into a tuple and store it in the result variable.
  5. Print the result.

Python3




import itertools
 
# Initializing list
test_tup1 = (10, 4, 5, 6)
test_tup2 = (5, 6, 7, 5)
 
# Printing original tuples
print("The original tuple 1 : " + str(test_tup1))
print("The original tuple 2 : " + str(test_tup2))
 
result = tuple(itertools.starmap(lambda x, y: x %
                                 y, zip(test_tup1, test_tup2)))
 
# Printing the result
print("The modulus tuple : " + str(result))
 
# This code is contributed by Jyothi pinjala.


Output

The original tuple 1 : (10, 4, 5, 6)
The original tuple 2 : (5, 6, 7, 5)
The modulus tuple : (0, 4, 5, 1)

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

Method #7: Using heapq

Algorithm:

  1. Initialize two tuples test_tup1 and test_tup2 with some elements.
  2. Calculate the modulus of the corresponding elements of the two tuples using zip() and a generator expression.
  3. Pass the generator expression to heapq.nlargest() with the len(test_tup1) argument to get the modulus of all the pairs of elements.
  4. Convert the result to a tuple using tuple() and assign it to modulus_tup.
  5. Print the original tuples and the modulus tuple.

Python3




import heapq
 
test_tup1 = (10, 4, 5, 6)
test_tup2 = (5, 6, 7, 5)
 
modulus_tup = tuple(heapq.nlargest(len(test_tup1), (x % y for x, y in zip(test_tup1, test_tup2))))
 
print("The original tuple 1 : " + str(test_tup1))
print("The original tuple 2 : " + str(test_tup2))
print("The modulus tuple : " + str(modulus_tup))
#This code is contributed by Rayudu.


Output

The original tuple 1 : (10, 4, 5, 6)
The original tuple 2 : (5, 6, 7, 5)
The modulus tuple : (5, 4, 1, 0)

Time Complexity: O(N)

The time complexity of this code is O(n log n), where n is the length of the input tuples. This is because heapq.nlargest() is used to calculate the modulus tuple, and its time complexity is O(n log k), where k is the length of the heap. In this case, k is equal to the length of the input tuples, so the time complexity is O(n log n).

Auxiliary Space: O(N)

The space complexity of this code is O(n), where n is the length of the input tuples. This is because a generator expression is used to calculate the modulus tuple, and its space complexity is O(1). The result of the generator expression is then converted to a tuple using tuple(), which has a space complexity of O(n). The space complexity of test_tup1, test_tup2, and modulus_tup is also O(n) since they all have n elements.

Method #8: Using List Comprehension

Approach:

  1. Initialize two tuples: test_tup1 and test_tup2 with integer values.
  2. Using list comprehension, apply modulus operator to each pair of elements from test_tup1 and test_tup2 tuples.
  3. Store the result in the res variable.
  4. Print the original tuples and the modulus tuple.

Python3




# Python3 code to demonstrate working of
# Tuple modulo
# using List comprehension
 
# initialize tuples
test_tup1 = (10, 4, 5, 6)
test_tup2 = (5, 6, 7, 5)
 
# printing original tuples
print("The original tuple 1 : " + str(test_tup1))
print("The original tuple 2 : " + str(test_tup2))
 
# Tuple modulo
# using List comprehension
res = [ele1 % ele2 for ele1, ele2 in zip(test_tup1, test_tup2)]
res = tuple(res)
 
# printing result
print("The modulus tuple : " + str(res))


Output

The original tuple 1 : (10, 4, 5, 6)
The original tuple 2 : (5, 6, 7, 5)
The modulus tuple : (0, 4, 5, 1)

Time complexity: O(n), where n is the length of the tuples.
Auxiliary space: O(n), where n is the length of the tuples, because we are storing the result in a list before converting it to a tuple.



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