Python - Ordered tuples extraction

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 code to demonstrate working of 
# Ordered tuples extraction
# Using list comprehension + sorted()

# initializing list
test_list = [(5, 4, 6, 2, 4), (3, 4, 6), (9, 10, 34), (2, 5, 6), (9, 1)]

# printing original list
print("The original list is : " + str(test_list))

# sorted() used to order, comparison operator to test 
res = [sub for sub in test_list if tuple(sorted(sub)) == sub]

# printing result 
print("Ordered Tuples : " + str(res))

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 code to demonstrate working of 
# Ordered tuples extraction
# Using filter() + lambda + sorted()

# initializing list
test_list = [(5, 4, 6, 2, 4), (3, 4, 6), (9, 10, 34), (2, 5, 6), (9, 1)]

# printing original list
print("The original list is : " + str(test_list))

# sorted() used to order, comparison operator to test 
res = list(filter(lambda sub: tuple(sorted(sub)) == sub, test_list))

# printing result 
print("Ordered Tuples : " + str(res))

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.

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)

# initializing list
test_list = [(5, 4, 6, 2, 4), (3, 4, 6), (9, 10, 34), (2, 5, 6), (9, 1)]

# printing original list
print("The original list is : " + str(test_list))

# calling function to extract ordered tuples
res = ordered_tuples(test_list)

# printing result
print("Ordered Tuples : " + str(res))
#this code contributed by tvsk

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:

test_list = [(5, 4, 6, 2, 4), (3, 4, 6), (9, 10, 34), (2, 5, 6), (9, 1)]

# printing original list
print("The original list is : " + str(test_list))
# Using all() to filter ordered tuples
ordered_tuples = list(filter(lambda tup: all(tup[i] <= tup[i+1] for i in range(len(tup)-1)), test_list))

# Print the result
print("Ordered Tuples: ", ordered_tuples)
#This code is contributed by Vinay Pinjala.

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

import itertools

test_list = [(5, 4, 6, 2, 4), (3, 4, 6), (9, 10, 34), (2, 5, 6), (9, 1)]
# printing original list
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)

#This code is contributed by Jyothi pinjala.

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:

1. Define a list of tuples named "test_list" containing multiple tuples with different number of integers in each tuple.
2. Create an empty list named "res".
3. Iterate through each tuple "tup" in the "test_list".
4. 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.
5. Then, convert the output of "map" function to set using "set" function.
6. Check if the set obtained in the previous step is equal to the set containing the original tuple "tup" using "==" operator.
7. If the sets are equal, then the tuple "tup" is ordered. Append it to the list "res".
8. 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:

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)

Ordered Tuples:  [(3, 4, 6), (9, 10, 34), (2, 5, 6)]

Time complexity: O(nklog k)
Auxiliary space: O(n*k)