Given a tuple list, get all the tuples which are sorted in ascending order.
Input : test_list = [(5, 4, 6, 2, 4), (3, 4, 6), (2, 5, 6), (9, 1)]
Output : [(3, 4, 6), (2, 5, 6)]
Explanation : Sorted tuples are extracted.
Input : test_list = [(5, 4, 6, 2, 4), (3, 4, 1), (2, 5, 4), (9, 1)]
Output : []
Explanation : No Sorted tuples.
Method #1 : Using list comprehension + sorted()
In this, we check if tuple is ordered using sorted(), and list comprehension is used to iterate for each tuple.
Python3
test_list = [( 5 , 4 , 6 , 2 , 4 ), ( 3 , 4 , 6 ), ( 9 , 10 , 34 ), ( 2 , 5 , 6 ), ( 9 , 1 )]
print ( "The original list is : " + str (test_list))
res = [sub for sub in test_list if tuple ( sorted (sub)) = = sub]
print ( "Ordered Tuples : " + str (res))
|
Output
The original list is : [(5, 4, 6, 2, 4), (3, 4, 6), (9, 10, 34), (2, 5, 6), (9, 1)]
Ordered Tuples : [(3, 4, 6), (9, 10, 34), (2, 5, 6)]
Time Complexity: O(nlogn), where n is the length of the input list.
Auxiliary Space: O(n) additional space of size n is created where n is the number of elements in the list “test_list”.
Method #2 : Using filter() + lambda + sorted()
In this, the task of filtering is done using filter(), sorted() fed to lambda for with comparison to get required result.
Python3
test_list = [( 5 , 4 , 6 , 2 , 4 ), ( 3 , 4 , 6 ), ( 9 , 10 , 34 ), ( 2 , 5 , 6 ), ( 9 , 1 )]
print ( "The original list is : " + str (test_list))
res = list ( filter ( lambda sub: tuple ( sorted (sub)) = = sub, test_list))
print ( "Ordered Tuples : " + str (res))
|
Output
The original list is : [(5, 4, 6, 2, 4), (3, 4, 6), (9, 10, 34), (2, 5, 6), (9, 1)]
Ordered Tuples : [(3, 4, 6), (9, 10, 34), (2, 5, 6)]
Method#3: Using Recursive method.
Python3
def ordered_tuples(test_list, result = []):
if len (test_list) = = 0 :
return result
else :
first, * rest = test_list
if tuple ( sorted (first)) = = first:
result.append(first)
return ordered_tuples(rest, result)
test_list = [( 5 , 4 , 6 , 2 , 4 ), ( 3 , 4 , 6 ), ( 9 , 10 , 34 ), ( 2 , 5 , 6 ), ( 9 , 1 )]
print ( "The original list is : " + str (test_list))
res = ordered_tuples(test_list)
print ( "Ordered Tuples : " + str (res))
|
Output
The original list is : [(5, 4, 6, 2, 4), (3, 4, 6), (9, 10, 34), (2, 5, 6), (9, 1)]
Ordered Tuples : [(3, 4, 6), (9, 10, 34), (2, 5, 6)]
Time Complexity: O(n)
Auxiliary Space: O(n)
Method #4: Using all()
Step-by-step approach:
- Traverse through each character in the string.
- For each character, check if it is an opening parenthesis or closing parenthesis. If it is an opening parenthesis, push it to the stack. If it is a closing parenthesis, check if the stack is empty or the top of the stack is not the corresponding opening parenthesis for the closing parenthesis. If it is, return False.
- After traversing through the string, check if the stack is empty. If it is, return True. If it is not, return False.
Below is the implementation of the above approach:
Python3
test_list = [( 5 , 4 , 6 , 2 , 4 ), ( 3 , 4 , 6 ), ( 9 , 10 , 34 ), ( 2 , 5 , 6 ), ( 9 , 1 )]
print ( "The original list is : " + str (test_list))
ordered_tuples = list ( filter ( lambda tup: all (tup[i] < = tup[i + 1 ] for i in range ( len (tup) - 1 )), test_list))
print ( "Ordered Tuples: " , ordered_tuples)
|
Output
The original list is : [(5, 4, 6, 2, 4), (3, 4, 6), (9, 10, 34), (2, 5, 6), (9, 1)]
Ordered Tuples: [(3, 4, 6), (9, 10, 34), (2, 5, 6)]
Time complexity: The time complexity of this approach is O(n), where n is the length of the input string. This is because we need to traverse through each character in the string once.
Auxiliary space: The auxiliary space complexity of this approach is O(n), where n is the length of the input string. This is because we need to store the opening parenthesis in the stack and the maximum size of the stack is equal to the length of the input string.
Method #5: Using the itertools.groupby() function:
Algorithm:
1.Import itertools module
2.Initialize an empty list ordered_tuples to store ordered tuples
3.Iterate over the groups returned by itertools.groupby() method, grouped based on whether each tuple satisfies the ordering condition
4.If a group contains only ordered tuples, extend the ordered_tuples list with the tuples in the group
5.Print the ordered_tuples list
Python3
import itertools
test_list = [( 5 , 4 , 6 , 2 , 4 ), ( 3 , 4 , 6 ), ( 9 , 10 , 34 ), ( 2 , 5 , 6 ), ( 9 , 1 )]
print ( "The original list is : " + str (test_list))
ordered_tuples = []
for k, g in itertools.groupby(test_list, lambda tup: all (tup[i] < = tup[i + 1 ] for i in range ( len (tup) - 1 ))):
if k:
ordered_tuples.extend(g)
print ( "Ordered Tuples: " , ordered_tuples)
|
Output
The original list is : [(5, 4, 6, 2, 4), (3, 4, 6), (9, 10, 34), (2, 5, 6), (9, 1)]
Ordered Tuples: [(3, 4, 6), (9, 10, 34), (2, 5, 6)]
Time complexity: O(nlogn) where n is the total number of elements in all tuples. This is because the itertools.groupby() method and the all() function take O(n) time complexity, while the extend() method takes O(m) time complexity, where m is the number of elements in the group of ordered tuples. The total time complexity is dominated by the sorting that happens inside itertools.groupby(), which has a time complexity of O(nlogn).
Auxiliary Space: O(m) where m is the number of elements in the largest group of ordered tuples. This is because the itertools.groupby() method groups the input list into separate sublists, and the largest sublist needs to be stored in memory.
Method #6: Using map() and set()
Step-by-step approach:
- Define a list of tuples named “test_list” containing multiple tuples with different number of integers in each tuple.
- Create an empty list named “res”.
- Iterate through each tuple “tup” in the “test_list”.
- For each “tup”, sort the integers using “sorted” function and convert the sorted integers into tuple using “tuple” function. Then, map the tuple of sorted integers to “map” function.
- Then, convert the output of “map” function to set using “set” function.
- Check if the set obtained in the previous step is equal to the set containing the original tuple “tup” using “==” operator.
- If the sets are equal, then the tuple “tup” is ordered. Append it to the list “res”.
- After iterating through all tuples in the “test_list”, print the list “res” containing all ordered tuples.
Below is the implementation of the above approach:
Python3
test_list = [( 5 , 4 , 6 , 2 , 4 ), ( 3 , 4 , 6 ), ( 9 , 10 , 34 ), ( 2 , 5 , 6 ), ( 9 , 1 )]
res = []
for tup in test_list:
if set ( map ( tuple , map ( sorted , [tup]))) = = {tup}:
res.append(tup)
print ( "Ordered Tuples: " , res)
|
Output
Ordered Tuples: [(3, 4, 6), (9, 10, 34), (2, 5, 6)]
Time complexity: O(nklog k)
Auxiliary space: O(n*k)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...