Python | Arrange Tuples consecutively in list
Last Updated :
17 Apr, 2023
Sometimes, while working with tuple list, we may require a case in which we require that a tuple starts from the end of previous tuple, i.e the element 0 of every tuple should be equal to ending element of tuple in list of tuple. This type of problem and sorting is useful in competitive programming. Let’s discuss way in which this problem can be solved.
Method : Using loop + dict() This task can easily be solved by converting a tuple container list to dictionary and then it’s easy to access a value of a key and arrange them accordingly to sort in a way in which one tuple element begins with the ending of other element.
Python3
test_list = [( 5 , 6 ), ( 11 , 8 ), ( 6 , 11 ), ( 8 , 9 ) ]
print ("The original list is : " + str (test_list))
temp = dict (test_list)
ele = test_list[ 0 ][ 0 ]
res = []
for _ in range ( len (test_list)):
res.append((ele, temp[ele]))
ele = temp[ele]
print ("The arranged list is : " + str (res))
|
Output :
The original list is : [(5, 6), (11, 8), (6, 11), (8, 9)]
The arranged list is : [(5, 6), (6, 11), (11, 8), (8, 9)]
Time Complexity: O(n), where n is the length of the list test_list
Auxiliary Space: O(n) additional space of size n is created where n is the number of elements in the list
Method #2:Using the sorting and then comparing the values:
- Initialize the list of tuples.
- Sort the list based on the second element of each tuple.
- Loop through the list and compare each tuple with the next tuple.
- If the tuples are consecutive, continue to the next iteration of the loop.
- If the tuples are not consecutive, loop through the remaining tuples to find the tuple whose first element is equal to the second element of the current tuple, and swap it with the next tuple.
- Print the arranged list.
Python3
test_list = [( 5 , 6 ), ( 11 , 8 ), ( 6 , 11 ), ( 8 , 9 )]
print ( "The original list is:" , test_list)
arranged_list = sorted (test_list, key = lambda x: x[ 1 ])
for i in range ( len (arranged_list) - 1 ):
if arranged_list[i][ 1 ] = = arranged_list[i + 1 ][ 0 ]:
continue
else :
for j in range (i + 1 , len (arranged_list)):
if arranged_list[i][ 1 ] = = arranged_list[j][ 0 ]:
arranged_list[i + 1 ], arranged_list[j] = arranged_list[j], arranged_list[i + 1 ]
break
print ( "The arranged list is:" , arranged_list)
|
Output
The original list is: [(5, 6), (11, 8), (6, 11), (8, 9)]
The arranged list is: [(5, 6), (6, 11), (11, 8), (8, 9)]
Time complexity is O(n^2) in the worst case due to the nested loop
Auxiliary Space is O(n) because we use a sorted copy of the original list
Share your thoughts in the comments
Please Login to comment...