Python Program to Merge tuple list by overlapping mid tuple

Last Updated : 08 Apr, 2023

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

# Python3 code to demonstrate working of
# Merge tuple list by overlapping mid tuple
# Using loop


# initializing lists
test_list1 = [(4, 8), (19, 22), (28, 30), (91, 98)]
test_list2 = [(10, 22), (23, 26), (15, 20), (52, 58)]

# printing original lists
print("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 result
print("Merged Tuples : " + str(res))

Output

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.

Python3

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 lists
test_list1 = [(4, 8), (19, 22), (28, 30), (91, 98)]
test_list2 = [(10, 22), (23, 26), (15, 20), (52, 58)]

# printing original lists
print("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))

Output

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.

Python3

# initializing lists
test_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 comprehension
res = [(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 result
print("Merged Tuples : " + str(res))

Output

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.

Python3

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 lists
test_list1 = [(4, 8), (19, 22), (28, 30), (91, 98)]
test_list2 = [(10, 22), (23, 26), (15, 20), (52, 58)]

# printing original lists
print("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))

Output

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.

Python3

import heapq

test_list1 = [(4, 8), (19, 22), (28, 30), (91, 98)]
test_list2 = [(10, 22), (23, 26), (15, 20), (52, 58)]

# combine both lists
combined_list = test_list1 + test_list2

# sort the combined list by the starting index of the tuple
combined_list.sort(key=lambda x: x[0])

# create a heap and add the first tuple
heap = [combined_list[0]]

# initialize the result list
res = []

# iterate over the remaining tuples
for 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 list
while heap:
    res.append(heapq.heappop(heap))

# printing result
print("Merged Tuples : " + str(res))

Output

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.

Python3

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 lists
test_list1 = [(4, 8), (19, 22), (28, 30), (91, 98)]
test_list2 = [(10, 22), (23, 26), (15, 20), (52, 58)]

# printing original lists
print("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))

Output

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.