Python – Ordered tuples extraction
Last Updated : 17 Apr, 2023
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)
Similar Reads
Addition in Nested Tuples - Python
Sometimes, while working with records, we can have a problem in which we require to perform index wise addition of tuple elements. This can get complicated with tuple elements to be tuple and inner elements again be tuple. Let's discuss certain ways in which this problem can be solved. Method #1: Us
6 min read
Python - Order Tuples by List
Sometimes, while working with Python tuples, we can have a problem in which we need to perform ordering of all the tuples keys using external list. This problem can have application in data domains such as Data Science. Let's discuss certain ways in which this task can be performed. Input : test_lis
7 min read
Python - Flatten Nested Tuples
Sometimes, while working with Python Tuples, we can have a problem in which we need to perform flattening of tuples, which can be nested and undesired. This can have application across many domains such as Data Science and web development. Let's discuss certain way in which this task can be performe
7 min read
Create Dictionary Of Tuples - Python
The task of creating a dictionary of tuples in Python involves mapping each key to a tuple of values, enabling structured data storage and quick lookups. For example, given a list of names like ["Bobby", "Ojaswi"] and their corresponding favorite foods as tuples [("chapathi", "roti"), ("Paraota", "I
3 min read
Python - Extend consecutive tuples
Given list of tuples, join consecutive tuples. Input : test_list = [(3, 5, 6, 7), (3, 2, 4, 3), (9, 4), (2, 3, 2)] Output : [(3, 5, 6, 7, 3, 2, 4, 3), (3, 2, 4, 3, 9, 4), (9, 4, 2, 3, 2)] Explanation : Elements joined with their consecutive tuples. Input : test_list = [(3, 5, 6, 7), (3, 2, 4, 3)] Ou
3 min read
Python | Tuple XOR operation
Sometimes, while working with records, we can have a problem in which we may need to perform mathematical bitwise XOR operation across tuples. This problem can occur in day-day programming. Let’s discuss certain ways in which this task can be performed. Method #1: Using zip() + generator expression
6 min read
Python | Compare tuples
Sometimes, while working with records, we can have a problem in which we need to check if each element of one tuple is greater/smaller than it's corresponding index in other tuple. This can have many possible applications. Let's discuss certain ways in which this task can be performed. Method #1 : U
4 min read
Python Tuple - index() Method
While working with tuples many times we need to access elements at a certain index but for that, we need to know where exactly is that element, and here comes the use of the index() function. In this article, we will learn about the index() function used for tuples in Python. Example : The Index() m
3 min read
Python - Extract Symmetric Tuples
Sometimes while working with Python tuples, we can have a problem in which we need to extract all the pairs which are symmetric, i.e for any (x, y), we have (y, x) pair present. This kind of problem can have application in domains such as day-day programming and web development. Let's discuss certai
4 min read
Python - Pairwise Addition in Tuples
Sometimes, while working with data, we can have a problem in which we need to find cumulative result. This can be of any type, product or summation. Here we are gonna discuss about adjacent element addition. Let’s discuss certain ways in which this task can be performed. Method #1 : Using zip() + ge
4 min read