Python - Convert Tuple to Tuple Pair

Sometimes, while working with Python Tuple records, we can have a problem in which we need to convert Single tuple with 3 elements to pair of dual tuple. This is quite a peculiar problem but can have problems in day-day programming and competitive programming. Let's discuss certain ways in which this task can be performed.

Input : test_tuple = ('A', 'B', 'C') 
Output : [('A', 'B'), ('A', 'C')]

 Input : test_tuple = ('X', 'Y', 'Z') 
Output : [('X', 'Y'), ('X', 'Z')]

Method #1: Using product() + next() The combination of above functions can be used to solve this problem. In this, we make pairs using product, the selection of pairing with next element is done using nex(). 

step-by-step approach :

1. First, the program imports the product() function from the itertools module. This function computes the cartesian product of input iterables.
2. The program then creates a tuple called test_tuple containing three elements: 'G', 'F', and 'G'.
3. The program then prints the original tuple using the print() function and the str() function to convert the tuple to a string.
4. Next, the program creates an iterator object from the test_tuple using the iter() function.
5. The program then uses the next() function to retrieve the first element of the test_tuple iterator and passes it as the first argument to the product() function.
6. The second argument to the product() function is the test_tuple iterator itself. By passing the iterator as an argument, the program is able to generate a sequence of paired elements, where each element in the tuple is paired with every other element in the tuple.
7. The program then uses the list() function to convert the result of the product() function to a list.
8. Finally, the program prints the paired elements using the print() function and the str() function to convert the result to a string.

# Python3 code to demonstrate working of 
# Convert Tuple to Tuple Pair
# Using product() + next()
from itertools import product

# initializing tuple
test_tuple = ('G', 'F', 'G')

# printing original tuple
print("The original tuple : " + str(test_tuple))

# Convert Tuple to Tuple Pair
# Using product() + next()
test_tuple = iter(test_tuple)
res = list(product(next(test_tuple), test_tuple))

# printing result 
print("The paired records : " + str(res))

The original tuple : ('G', 'F', 'G')
The paired records : [('G', 'F'), ('G', 'G')]

Time complexity: O(n^2), where n is the length of the input tuple.
Auxiliary space: O(n^2), as the result is stored in a list of pairs. However, the input tuple is not modified, so it does not contribute to the auxiliary space complexity.

Method #2: Using repeat() + zip() + next() This problem can also be solved using the combination of above functions. In this we perform the task of pairing using zip() and repetition using repeat(). 

• Import the repeat() function from the itertools module.
• Initialize a tuple named test_tuple with three elements: 'G', 'F', and 'G'.
• Print the original tuple using the print() function and string concatenation.
• Convert the original tuple to a tuple of pairs using repeat(), zip(), and next().
  • Convert the original tuple to an iterator using the iter() function and store it in test_tuple.
  • Use the next() function to get the first element from test_tuple and repeat it infinitely using repeat().
  • Use zip() to combine the repeated first element with the rest of test_tuple.
  • Convert the result to a list using the list() function and store it in res.
• Print the paired records using the print() function and string concatenation.

# Python3 code to demonstrate working of 
# Convert Tuple to Tuple Pair
# Using repeat() + zip() + next()
from itertools import repeat

# initializing tuple
test_tuple = ('G', 'F', 'G')

# printing original tuple
print("The original tuple : " + str(test_tuple))

# Convert Tuple to Tuple Pair
# Using repeat() + zip() + next()
test_tuple = iter(test_tuple)
res = list(zip(repeat(next(test_tuple)), test_tuple))

# printing result 
print("The paired records : " + str(res))

The original tuple : ('G', 'F', 'G')
The paired records : [('G', 'F'), ('G', 'G')]

Time complexity: O(n), where n is the length of the input tuple.
Auxiliary space: O(n), where n is the length of the input tuple. 

 Method 3: Using zip+ slicing

t = (1, 2, 3, 4)

pair_tuple = tuple(zip(t[:-1], t[1:]))

print(pair_tuple)  # Output: ((1, 2), (2, 3), (3, 4))

((1, 2), (2, 3), (3, 4))

Time Complexity: O(n)
Auxiliary Space: O(1)

Method #4: Using list comprehension

In this code, we first define the tuple t with some integer values. We then use a list comprehension to create a list of tuples, where each tuple contains two consecutive elements from the original tuple t. The list comprehension uses the for loop to iterate over the indices of t, and creates a tuple of the element at the current index and the element at the next index. The range(len(t)-1) in the loop condition ensures that the loop runs until the second-to-last element of the tuple, so that we don't go out of bounds when accessing the next index. Finally, we convert the list of tuples to a tuple using the tuple() function, and print the result.

t = (1, 2, 3, 4)
pair_tuple = tuple((t[i], t[i+1]) for i in range(len(t)-1))
print(pair_tuple)  
#This code is contributed by Vinay Pinjala.

((1, 2), (2, 3), (3, 4))

Time complexity: O(n), where n is the length of the input tuple. This is because we are iterating over the tuple once to create pairs of consecutive elements, and each iteration takes constant time. Therefore, the time taken by the algorithm grows linearly with the size of the input.
Auxiliary space: O(n), where n is the length of the input tuple. This is because we are creating a list of tuples to hold the consecutive element pairs, which can have up to n-1 elements in the worst case. We then convert this list to a tuple using the tuple() function, which creates a new tuple object in memory. Therefore, the space taken by the algorithm is proportional to the size of the input.

Method #5: Using a for loop and list comprehension

The below code defines a tuple t containing the integers 1 through 4. The code then creates a new tuple of pairs by iterating over t using a list comprehension and selecting adjacent elements. The resulting pairs are stored in a tuple named pair_tuple. Finally, the code prints the resulting tuple of pairs to the console.

# Define a tuple of integers
t = (1, 2, 3, 4)

# Create a tuple of pairs by iterating over `t` and selecting adjacent elements
pair_tuple = tuple((t[i], t[i+1]) for i in range(len(t)-1))

# Print the tuple of pairs
print(pair_tuple)

((1, 2), (2, 3), (3, 4))

Time complexity: O(n), where n is the length of the input tuple.
Auxiliary Space: O(n)

Method #6: Recursive method.

The algorithm of the recursive method that creates a tuple of pairs from adjacent elements in a tuple is as follows:

1. If the length of the input tuple t is less than 2, return an empty tuple since there are no adjacent pairs to form.
2. If the length of the input tuple t is greater than or equal to 2, create a new tuple of pairs by iterating over the indices of the input tuple from 0 to len(t)-2, and combining each element with its adjacent element. Return this tuple of pairs.
3. Recursively call the pair_tuple function with the input tuple t without its first element, and concatenate the result with the current tuple of pairs. This step is repeated until the length of the input tuple is less than 2.

def pair_tuple(t):
    # Base case: if the tuple has less than two elements, return an empty tuple
    if len(t) < 2:
        return ()

    # Recursive case: create a tuple of pairs by combining each element with its adjacent element
    return ((t[i], t[i+1]) for i in range(len(t)-1))

# Define a tuple of integers
t = (1, 2, 3, 4)

# Create a tuple of pairs by calling the pair_tuple function
pair_tuple = tuple(pair_tuple(t))

# Print the tuple of pairs
print(pair_tuple)

((1, 2), (2, 3), (3, 4))

The time complexity of this algorithm is O(n), where n is the length of the input tuple, since it requires iterating over the input tuple once. 

The auxiliary space of the algorithm is also O(n), since it requires storing the tuple of pairs created during each recursive call on the call stack.

Method #7: Using map() function

Step-by-step approach:

• Define the pair_tuple function which takes a tuple t as input.
• Use the map() function to create a new iterator of tuples where each tuple consists of two consecutive elements of the original tuple.
• Convert the iterator to a tuple using the tuple() function.
• Return the resulting tuple.

Below is the implementation of the above approach:

def pair_tuple(t):
    # Use the map() function to create an iterator of tuples
    pairs_iter = map(lambda i: (t[i], t[i+1]), range(len(t)-1))

    # Convert the iterator to a tuple
    pairs = tuple(pairs_iter)

    return pairs
# Define a tuple of integers
t = (1, 2, 3, 4)

# Create a tuple of pairs by calling the pair_tuple function
pair_tuple = pair_tuple(t)

# Print the tuple of pairs
print(pair_tuple)

((1, 2), (2, 3), (3, 4))

Time complexity: O(n), where n is the length of the input tuple t, as we need to iterate over each element of the tuple once.
Auxiliary space: O(n), as we need to store the resulting tuple in memory.

Method #8: Using numpy:

 Algorithm :

1. Define the tuple of integers t.
2. Print the original tuple t.
3. Convert the tuple to a numpy array a.
4. Shift the array by one element to the left.
5. Combine the original and shifted arrays into pairs and convert to a tuple.
6. Remove the last pair from the tuple.
7. Print the resulting tuple of pairs.

import numpy as np

# Define a tuple of integers
t = (1, 2, 3, 4)
# printing original tuple
print("The original tuple : " + str(t))
 
# Convert the tuple to a numpy array
a = np.array(t)

# Shift the array by one element
shifted_a = np.roll(a, -1)

# Combine the original and shifted arrays and reshape into pairs
res = tuple(zip(a, shifted_a))[:-1]


# printing result
print("The paired records : " + str(res))
#This code is contributed by Rayudu.

Output:

The original tuple : (1, 2, 3, 4)
The paired records : ((1, 2), (2, 3), (3, 4))

The time complexity: O(n), where n is the length of the input tuple. This is because the code goes through the tuple once to convert it to a numpy array, goes through it again to shift the array, and goes through it a third time to combine adjacent elements into pairs.

The space complexity : O(n), where n is the length of the input tuple. This is because the code stores the input tuple as a numpy array, which requires O(n) space, and creates a new tuple of pairs that has the same length as the input tuple, which also requires O(n) space.