Given two lists that contain tuples as elements, the task is to write a Python program to accommodate tuples from the second list between consecutive tuples from the first list, after considering ranges present between both the consecutive tuples from the first list.
Input : test_list1 = [(4, 8), (19, 22), (28, 30), (31, 50)], test_list2 = [(10, 12), (23, 26), (15, 20), (52, 58)]
Output : [((4, 8), (10, 12), (19, 22)), ((19, 22), (23, 26), (28, 30)), ((4, 8), (15, 20), (19, 22))]
Explanation : (4, 8) followed by (19, 22) can accommodate (10, 12) as 10 > 8 and 12 < 19.Input : test_list1 = [(4, 8), (19, 22), (28, 30), (31, 50)], test_list2 = [(10, 22), (23, 26), (15, 20), (52, 58)]
Output : [((19, 22), (23, 26), (28, 30)), ((4, 8), (15, 20), (19, 22))]
Explanation : (23, 26) can be accommodated between tuples.
Method: Using loop
In this, we keep two pointers one for each container, and the other for each element in list 1. Now, check if any tuple from list 2 can satisfy the required condition, if not, the following consecutive elements are considered for the next set of iterations.
Example:
# Python3 code to demonstrate working of# Merge tuple list by overlapping mid tuple# Using loop# initializing liststest_list1 = [(4, 8), (19, 22), (28, 30), (91, 98)]
test_list2 = [(10, 22), (23, 26), (15, 20), (52, 58)]
# printing original listsprint("The original list 1 is : " + str(test_list1))
print("The original list 2 is : " + str(test_list2))
idx = 0
j = 0
res = list()
# iterating till anyone of list exhausts.while j < len(test_list2):
# checking for mid tuple and appending
if test_list2[j][0] > test_list1[idx][0]\
and test_list2[j][1] < test_list1[idx + 1][1]:
# appending the range element from 2nd list which
# fits consecution along with original elements
# from 1st list.
res.append((test_list1[idx], test_list2[j], test_list1[idx + 1]))
j += 1
idx = 0
else:
# if not, the 1st list is iterated and next two
# ranges are compared for a fit.
idx += 1
# restart indices once limits are checked.
if idx == len(test_list1) - 1:
idx = 0
j += 1
# printing resultprint("Merged Tuples : " + str(res))
|
The original list 1 is : [(4, 8), (19, 22), (28, 30), (91, 98)] The original list 2 is : [(10, 22), (23, 26), (15, 20), (52, 58)] Merged Tuples : [((19, 22), (23, 26), (28, 30)), ((4, 8), (15, 20), (19, 22)), ((28, 30), (52, 58), (91, 98))]
Time Complexity: O(n), where n is the length of the given list test_list2
Auxiliary Space: O(n)
Method#2: Using Recursive method.
Algorithm:
- Define a recursive function merge_tuple_lists that takes two tuple lists test_list1 and test_list2, along with optional parameters idx, j, and res.
- Check if the base case is reached, i.e., if j is equal to the length of test_list2. If so, return the result list res.
- Check if the mid tuple condition is met, i.e., if the first element of the current tuple in test_list2 is greater than the first element of the current tuple in test_list1, and the second element of the current tuple in test_list2 is less than the second element of the next tuple in test_list1.
- If the mid tuple condition is met, append a tuple to the result list that contains the current tuple in test_list1, the current tuple in test_list2, and the next tuple in test_list1.
- Increment j by 1 and set idx to 0.
- If the mid tuple condition is not met, increment idx by 1.
- If idx is equal to the length of test_list1 – 1, set idx to 0 and increment j by 1 to move to the next tuple in test_list2.
- Recursively call merge_tuple_lists with the updated indices and result list.
- Return the final result list.
import itertools
def merge_tuple_lists(test_list1, test_list2):
# create an iterator that alternates between elements of test_list1 and test_list2
it = itertools.chain.from_iterable(zip(test_list1, test_list2))
# loop through the iterator and merge consecutive tuples
res = []
prev = next(it)
for curr in it:
if curr[0] < prev[1]:
# the current tuple overlaps with the previous tuple, merge them
res.append((prev[0], curr[1]))
else:
# the current tuple does not overlap with the previous tuple, add the previous tuple to the result
res.append(prev)
prev = curr
# add the last tuple to the result
res.append(prev)
return res
# initializing liststest_list1 = [(4, 8), (19, 22), (28, 30), (91, 98)]
test_list2 = [(10, 22), (23, 26), (15, 20), (52, 58)]
# printing original listsprint("The original list 1 is : " + str(test_list1))
print("The original list 2 is : " + str(test_list2))
res = merge_tuple_lists(test_list1, test_list2)
print("Merged Tuples : " + str(res))
|
The original list 1 is : [(4, 8), (19, 22), (28, 30), (91, 98)] The original list 2 is : [(10, 22), (23, 26), (15, 20), (52, 58)] Merged Tuples : [((19, 22), (23, 26), (28, 30)), ((4, 8), (15, 20), (19, 22)), ((28, 30), (52, 58), (91, 98))]
Time Complexity:
The time complexity of the code is O(n^2), where n is the length of the longer list (test_list1 or test_list2). This is because the function needs to iterate through each tuple in both lists to find the overlapping mid tuples. However, in practice, the time complexity will likely be much lower since the function can exit early if it reaches the end of test_list2.
Space Complexity:
The space complexity of the code is also O(n^2), where n is the length of the longer list (test_list1 or test_list2). This is because the function creates a result list that can potentially contain all possible overlapping mid tuples. Again, in practice, the space complexity will likely be much lower since the result list will only contain the actual overlapping mid tuples.
Method 3-“Efficient Merging of Tuple Lists with Overlapping Mid Tuples using List Comprehension in Python”
In this method we iterates over all possible combinations of tuples from both lists, and checks if the mid tuple of the second list falls between the first and third tuples of the first list. If the condition is true, it appends the tuple sequence (t1, t2, t3) to the result list.
# initializing liststest_list1 = [(4, 8), (19, 22), (28, 30), (91, 98)]
test_list2 = [(10, 22), (23, 26), (15, 20), (52, 58)]
# creating a new list using list comprehensionres = [(t1, t2, t3) for t1 in test_list1 for t2 in test_list2 for t3 in test_list1 if t2[0] > t1[0] and t2[1] < t3[1] and t3[0] > t2[0] and t3[1] > t2[1]]
# printing resultprint("Merged Tuples : " + str(res))
|
Merged Tuples : [((4, 8), (10, 22), (28, 30)), ((4, 8), (10, 22), (91, 98)), ((4, 8), (23, 26), (28, 30)), ((4, 8), (23, 26), (91, 98)), ((4, 8), (15, 20), (19, 22)), ((4, 8), (15, 20), (28, 30)), ((4, 8), (15, 20), (91, 98)), ((4, 8), (52, 58), (91, 98)), ((19, 22), (23, 26), (28, 30)), ((19, 22), (23, 26), (91, 98)), ((19, 22), (52, 58), (91, 98)), ((28, 30), (52, 58), (91, 98))]
Time complexity: O(n^3) where n is the length of the input lists
Auxiliary space: O(n^3), as the resulting list can potentially contain all possible tuple sequences that meet the condition.
Method 4: Using the built-in zip() function and itertools.chain() function
This implementation first creates an iterator that alternates between elements of test_list1 and test_list2. Then it loops through this iterator and merges consecutive tuples if they overlap. Finally, it appends the last tuple to the result.
import itertools
def merge_tuple_lists(test_list1, test_list2):
# create an iterator that alternates between elements of test_list1 and test_list2
it = itertools.chain.from_iterable(zip(test_list1, test_list2))
# loop through the iterator and merge consecutive tuples
res = []
prev = next(it)
for curr in it:
if curr[0] < prev[1]:
# the current tuple overlaps with the previous tuple, merge them
res.append((prev[0], curr[1]))
else:
# the current tuple does not overlap with the previous tuple, add the previous tuple to the result
res.append(prev)
prev = curr
# add the last tuple to the result
res.append(prev)
return res
# initializing liststest_list1 = [(4, 8), (19, 22), (28, 30), (91, 98)]
test_list2 = [(10, 22), (23, 26), (15, 20), (52, 58)]
# printing original listsprint("The original list 1 is : " + str(test_list1))
print("The original list 2 is : " + str(test_list2))
res = merge_tuple_lists(test_list1, test_list2)
print("Merged Tuples : " + str(res))
|
The original list 1 is : [(4, 8), (19, 22), (28, 30), (91, 98)] The original list 2 is : [(10, 22), (23, 26), (15, 20), (52, 58)] Merged Tuples : [(4, 8), (10, 22), (19, 22), (23, 26), (28, 20), (15, 20), (91, 58), (52, 58)]
Time complexity: O(n), where n is the total number of tuples in both input lists.
Auxiliary space: O(1) because it does not use any additional data structures beyond the input lists and the output list.
Method 5: Using the heapq module
This method uses a heap to merge the tuples efficiently by taking advantage of the sorted order of the combined list. It works by adding the tuples to a heap, and merging overlapping tuples as necessary. The result is a list of non-overlapping tuples that covers all the original tuples.
import heapq
test_list1 = [(4, 8), (19, 22), (28, 30), (91, 98)]
test_list2 = [(10, 22), (23, 26), (15, 20), (52, 58)]
# combine both listscombined_list = test_list1 + test_list2
# sort the combined list by the starting index of the tuplecombined_list.sort(key=lambda x: x[0])
# create a heap and add the first tupleheap = [combined_list[0]]
# initialize the result listres = []
# iterate over the remaining tuplesfor i in range(1, len(combined_list)):
# get the current tuple
curr_tuple = combined_list[i]
# if the current tuple overlaps with the last tuple in the heap
if curr_tuple[0] <= heap[-1][1]:
# merge the current tuple with the last tuple in the heap
merged_tuple = (heap[-1][0], max(heap[-1][1], curr_tuple[1]))
# remove the last tuple from the heap
heapq.heappop(heap)
# add the merged tuple to the heap
heapq.heappush(heap, merged_tuple)
else:
# add the current tuple to the heap
heapq.heappush(heap, curr_tuple)
# iterate over the heap and append the tuples to the result listwhile heap:
res.append(heapq.heappop(heap))
# printing resultprint("Merged Tuples : " + str(res))
|
Merged Tuples : [(10, 22), (10, 22), (23, 26), (28, 30), (52, 58), (91, 98)]
Time complexity: O(n log n), where n is the total number of tuples in the input lists.
Space complexity: O(n), where n is the total number of tuples in the input lists.
Method 6: Using a dictionary to group overlapping tuples
Here is an approach :
- Initialize an empty dictionary to store the grouped tuples.
- Loop through the tuples in test_list1 and test_list2.
- For each tuple, check if it overlaps with any of the existing groups in the dictionary.
- If it overlaps with a group, merge the tuples and add them to the group.
- If it does not overlap with any group, create a new group in the dictionary with the current tuple.
- Convert the dictionary values (which are lists of merged tuples) to a single list of tuples and return it.
def merge_tuple_lists(test_list1, test_list2):
# initialize dictionary to store grouped tuples
groups = {}
# loop through tuples in both lists
for tup in test_list1 + test_list2:
merged = False
# check if the current tuple overlaps with any group
for group in groups.values():
if group[-1][1] >= tup[0] and group[0][0] <= tup[1]:
# merge the tuples
group.append(tup)
merged = True
break
# if the tuple does not overlap with any group, create a new group
if not merged:
groups[len(groups)] = [tup]
# convert dictionary values to a list of tuples
res = [t for group in groups.values() for t in group]
return res
# initializing liststest_list1 = [(4, 8), (19, 22), (28, 30), (91, 98)]
test_list2 = [(10, 22), (23, 26), (15, 20), (52, 58)]
# printing original listsprint("The original list 1 is : " + str(test_list1))
print("The original list 2 is : " + str(test_list2))
res = merge_tuple_lists(test_list1, test_list2)
print("Merged Tuples : " + str(res))
|
The original list 1 is : [(4, 8), (19, 22), (28, 30), (91, 98)] The original list 2 is : [(10, 22), (23, 26), (15, 20), (52, 58)] Merged Tuples : [(4, 8), (19, 22), (10, 22), (15, 20), (28, 30), (91, 98), (23, 26), (52, 58)]
Time Complexity: O(n), where n is the total number of tuples in both lists.
Auxiliary Space: O(n), where n is the total number of tuples in both lists.