Input: N = 5, M = 3 A = [6, 5, 7, 1, 3] B = [2, 4, 8] Output: 2 0 2 1 2 2 3 0 4 0 1 0 0 0 We have to form 5 + 3 - 1 = 7 pairs. These pairs are: (7, 2), (7, 4), (7, 8), (1, 2), (3, 2), (5, 2), (6, 2) All have unique sumBrute Force Approach: We can run a loop on both arrays A and B to find the first N+M-1 unique sum pairs, and print their indexes along the way. To check if a particular sum has already been used, we make a python bool dictionary. If the dictionary value for that sum is False, that means it is a new sum value. If it is True, the sum has already been used.
Code:
Output:
).
Efficient Approach: Once we sort both the arrays, first we can make N unique sum pairs by pairing all elements of array A with the first element of array B, and then pairing the other M – 1 elements of array B with the last element of array A.
Code:
Output:
from collections import defaultdict as dd
# Function to form unique sum pairs def unique_pairs():
# Python Bool Dictionary
d = dd( bool )
ct = 0
# For every element of A, Find
# a unique sum pair in B. Break
# the loop after N + M-1 pairs
for i in range (n):
for j in range (m):
if (ct = = n + m - 1 ):
break
sm = a[i] + b[j]
if (d[sm] = = False ):
d[sm] = True
ct + = 1
print (i, j)
n, m = 6 , 4
a = [ 6 , 4 , 3 , 5 , 8 , 2 ]
b = [ 3 , 5 , 4 , 2 ]
unique_pairs() |
0 0 0 1 0 2 0 3 1 0 1 3 2 3 4 1 4 2Time Complexity: Since we traverse the array with nested loops, the time complexity comes out to be O(
from collections import defaultdict as dd
# Function to form unique sum pairs def unique_pairs_sort():
# Python Int Dictionary
da = dd( int )
db = dd( int )
# Make a dictionary to store index
for i in range (n):
da[a[i]] = i
for i in range (m):
db[b[i]] = i
# Sorting the arrays
a.sort(); b.sort()
# N pairs of A with B[0]
for i in range (n):
print (da[a[i]], db[b[ 0 ]])
# M-1 pairs of B with A[N-1]
for i in range ( 1 , m):
print (da[a[ - 1 ]], db[b[i]])
n, m = 6 , 4
a = [ 6 , 4 , 3 , 5 , 8 , 2 ]
b = [ 3 , 5 , 4 , 2 ]
unique_pairs_sort() |
5 3 2 3 1 3 3 3 0 3 4 3 4 0 4 2 4 1Time Complexity: The complexity for this is equal to the time required for sorting: O(n Log n). Space Complexity: Since we are using two different maps/dictionaries to store the indexes of the array. The time complexity will be O(n + m) , where n is the size of first array and m is the size of second array.
Article Tags :
Recommended Articles