Python Program to Merge tuple list by overlapping mid tuple

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:

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:

1. 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.
2. 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.
3. 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.
4. 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.
5. Increment j by 1 and set idx to 0.
6. If the mid tuple condition is not met, increment idx by 1.
7. 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.
8. Recursively call merge_tuple_lists with the updated indices and result list.
9. Return the final result list.

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.

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.

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.

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 :

1. Initialize an empty dictionary to store the grouped tuples.
2. Loop through the tuples in test_list1 and test_list2.
3. For each tuple, check if it overlaps with any of the existing groups in the dictionary.
4. If it overlaps with a group, merge the tuples and add them to the group.
5. If it does not overlap with any group, create a new group in the dictionary with the current tuple.
6. Convert the dictionary values (which are lists of merged tuples) to a single list of tuples and return it.

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.