Python | Nested Records Modulo
Sometimes, while working with records, we can have a problem in which we require to perform index wise remainder of tuple elements. This can get complicated with tuple elements to be tuple and inner elements again be tuple. Let’s discuss certain ways in which this problem can be solved.
Method #1 : Using zip() + nested generator expression The combination of above functions can be used to perform the task. In this, we combine the elements across tuples using zip(). The iterations and modulo logic is provided by generator expression.
Python3
test_tup1 = (( 1 , 3 ), ( 4 , 5 ), ( 2 , 9 ), ( 1 , 10 ))
test_tup2 = (( 6 , 7 ), ( 3 , 9 ), ( 1 , 1 ), ( 7 , 3 ))
print ( "The original tuple 1 : " + str (test_tup1))
print ( "The original tuple 2 : " + str (test_tup2))
res = tuple ( tuple (a % b for a, b in zip (tup1, tup2))\
for tup1, tup2 in zip (test_tup1, test_tup2))
print ( "The resultant tuple after modulo : " + str (res))
|
Output
The original tuple 1 : ((1, 3), (4, 5), (2, 9), (1, 10))
The original tuple 2 : ((6, 7), (3, 9), (1, 1), (7, 3))
The resultant tuple after modulo : ((1, 3), (1, 5), (0, 0), (1, 1))
Time Complexity: O(n*n), where n is the number of elements in the list “test_tup”.
Auxiliary Space: O(n*n), where n is the number of elements in the list “test_tup”.
Method #2 : Using isinstance() + zip() + loop + list comprehension The combination of above functions can be used to perform this particular task. In this, we check for the nesting type and perform recursion. This method can give flexibility of more than 1 level nesting.
Python3
def tup_mod(tup1, tup2):
if isinstance (tup1, ( list , tuple )) and isinstance (tup2, ( list , tuple )):
return tuple (tup_mod(x, y) for x, y in zip (tup1, tup2))
return tup1 % tup2
test_tup1 = (( 1 , 3 ), ( 4 , 5 ), ( 2 , 9 ), ( 1 , 10 ))
test_tup2 = (( 6 , 7 ), ( 3 , 9 ), ( 1 , 1 ), ( 7 , 3 ))
print ( "The original tuple 1 : " + str (test_tup1))
print ( "The original tuple 2 : " + str (test_tup2))
res = tuple (tup_mod(x, y) for x, y in zip (test_tup1, test_tup2))
print ( "The resultant tuple after modulo : " + str (res))
|
Output
The original tuple 1 : ((1, 3), (4, 5), (2, 9), (1, 10))
The original tuple 2 : ((6, 7), (3, 9), (1, 1), (7, 3))
The resultant tuple after modulo : ((1, 3), (1, 5), (0, 0), (1, 1))
Time Complexity: O(n*n), where n is the length of the list test_tup
Auxiliary Space: O(n) additional space of size n is created where n is the number of elements in the res list
Method #3 : Using numpy
Note: Install numpy module using command “pip install numpy”
Python3
import numpy as np
test_tup1 = (( 1 , 3 ), ( 4 , 5 ), ( 2 , 9 ), ( 1 , 10 ))
test_tup2 = (( 6 , 7 ), ( 3 , 9 ), ( 1 , 1 ), ( 7 , 3 ))
arr1 = np.array(test_tup1)
arr2 = np.array(test_tup2)
result = np.mod(arr1, arr2)
result = result.tolist()
result = [ tuple (i) for i in result]
result = tuple (result)
print ( "The resultant tuple after modulo:" , result)
|
Output:
The resultant tuple after modulo: ((1, 3), (1, 5), (0, 0), (1, 1))
Explanation:
We start by importing Numpy library.
Then we initialize two nested tuples test_tup1 and test_tup2.
Next, we convert these nested tuples to Numpy arrays using np.array method.
Then we perform modulo operation on the arrays using np.mod method.
Finally, we convert the result back to nested tuples using the tolist method and list comprehension.
Method #4 : Using for loop + tuple() method
Python3
test_tup1 = (( 1 , 3 ), ( 4 , 5 ), ( 2 , 9 ), ( 1 , 10 ))
test_tup2 = (( 6 , 7 ), ( 3 , 9 ), ( 1 , 1 ), ( 7 , 3 ))
print ( "The original tuple 1 : " + str (test_tup1))
print ( "The original tuple 2 : " + str (test_tup2))
res = []
for i in range ( 0 , len (test_tup1)):
x = []
a = test_tup1[i][ 0 ] % test_tup2[i][ 0 ]
b = test_tup1[i][ 1 ] % test_tup2[i][ 1 ]
x.append(a)
x.append(b)
res.append( tuple (x))
print ( "The resultant tuple after modulo : " + str (res))
|
Output
The original tuple 1 : ((1, 3), (4, 5), (2, 9), (1, 10))
The original tuple 2 : ((6, 7), (3, 9), (1, 1), (7, 3))
The resultant tuple after modulo : [(1, 3), (1, 5), (0, 0), (1, 1)]
Time Complexity : O(N)
Auxiliary Space : O(N)
Method #5 : Using map() and lambda functions:
Python3
test_tup1 = (( 1 , 3 ), ( 4 , 5 ), ( 2 , 9 ), ( 1 , 10 ))
test_tup2 = (( 6 , 7 ), ( 3 , 9 ), ( 1 , 1 ), ( 7 , 3 ))
print ( "The original tuple 1 : " + str (test_tup1))
print ( "The original tuple 2 : " + str (test_tup2))
res = tuple ( map ( lambda x, y: tuple ( map ( lambda a, b: a % b, x, y)), test_tup1, test_tup2))
print ( "The resultant tuple after modulo : " + str (res))
|
Output
The original tuple 1 : ((1, 3), (4, 5), (2, 9), (1, 10))
The original tuple 2 : ((6, 7), (3, 9), (1, 1), (7, 3))
The resultant tuple after modulo : ((1, 3), (1, 5), (0, 0), (1, 1))
Time Complexity : O(N)
Auxiliary Space : O(N)
Last Updated :
27 Apr, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...