Python – Test if greater than preceding element in Tuple List
Last Updated :
18 May, 2023
Given list of tuples, check if preceding element is smaller than the current element for each element in Tuple list.
Input : test_list = [(5, 1), (4, 9), (3, 5)]
Output : [[False, False], [False, True], [False, True]]
Explanation : First element always being False, Next element is checked for greater value.
Input : test_list = [(1, 8), (2, 2), (3, 6), (4, 2)]
Output : [[False, True], [False, False], [False, True], [False, False]]
Explanation : 8 and 6 are greater cases in above cases, hence True.
Method #1 : Using list comprehension + enumerate() The combination of above functions can be used to solve this problem. In this, we perform the task of checking for greater value using one liner list comprehension and enumerate() is used to work with indices while nested iteration.
Python3
test_list = [(3, 5, 1), (7, 4, 9), (1, 3, 5)]
print("The original list : " + str(test_list))
res = [[True if idx > 0 and j > i[idx - 1] else False
for idx, j in enumerate(i)] for i in test_list]
print("Filtered values : " + str(res))
|
Output :
The original list : [(3, 5, 1), (7, 4, 9), (1, 3, 5)]
Filtered values : [[False, True, False], [False, False, True], [False, True, True]]
Time complexity: O(n^2), where n is the length of the longest tuple in the list. This is because the program iterates through each element of each tuple in the list using nested loops, and the length of the inner loop depends on the length of the longest tuple.
Auxiliary space: O(n^2), as it creates a new 2-dimensional list of the same size as the input list to store the boolean values for each element in each tuple.
Method #2 : Using tee() + zip() + list comprehension This is one of the ways in which this task can be performed. In this, we extract elements and render them in tuple of size = 2, using tee(). List comprehension and zip() are used to construct the desired result.
Python3
from itertools import tee
def pair(test_list):
x, y = tee(test_list)
next(y, None)
return zip(x, y)
test_list = [(3, 5, 1), (7, 4, 9), (1, 3, 5)]
print("The original list : " + str(test_list))
res = []
for sub in test_list:
res.append(tuple((False, )) + tuple([x < y for x, y in pair(sub)]))
print("Filtered values : " + str(res))
|
Output :
The original list : [(3, 5, 1), (7, 4, 9), (1, 3, 5)]
Filtered values : [[False, True, False], [False, False, True], [False, True, True]]
Time complexity: O(nm), where n is the length of the input list and m is the length of each tuple in the input list.
Auxiliary space: O(nm), where n is the length of the input list and m is the length of each tuple in the input list.
Method#3: Using a for loop and if-else statement
Python3
test_list = [(3, 5, 1), (7, 4, 9), (1, 3, 5)]
print("The original list : " + str(test_list))
res = []
for i in test_list:
sub_list = []
for idx, j in enumerate(i):
if idx > 0 and j > i[idx - 1]:
sub_list.append(True)
else:
sub_list.append(False)
res.append(sub_list)
print("Filtered values : " + str(res))
|
Output
The original list : [(3, 5, 1), (7, 4, 9), (1, 3, 5)]
Filtered values : [[False, True, False], [False, False, True], [False, True, True]]
Time complexity: O(n)
Auxiliary Space : O(n)
Method #4: Using map() + lambda function
You can use the map() function along with a lambda function to apply the same logic used in the for loop and if-else statement in a more concise way:
Python3
test_list = [(3, 5, 1), (7, 4, 9), (1, 3, 5)]
print("The original list : " + str(test_list))
res = list(map(lambda x: [x[idx] > x[idx-1] if idx > 0 else False for idx in range(len(x))], test_list))
print("Filtered values : " + str(res))
|
Output
The original list : [(3, 5, 1), (7, 4, 9), (1, 3, 5)]
Filtered values : [[False, True, False], [False, False, True], [False, True, True]]
Time complexity: O(n*m), where n is the number of tuples in the test_list, and m is the maximum number of elements in a tuple.
Auxiliary space: O(nm), where n is the number of tuples in the test_list, and m is the maximum number of elements in a tuple.
Method #5: Using a generator expression
In this approach, the generator expression (j > i[idx – 1] for idx, j in enumerate(i) if idx > 0) generates a boolean value for each element in the tuple, indicating whether it is greater than the preceding element. The all() function is used to check if all these boolean values are true for a given tuple, and the result is stored in a list comprehension.
Python3
test_list = [(3, 5, 1), (7, 4, 9), (1, 3, 5)]
print("The original list : " + str(test_list))
res = [all(j > i[idx - 1] for idx, j in enumerate(i) if idx > 0)
for i in test_list]
print("Filtered values : " + str(res))
|
Output
The original list : [(3, 5, 1), (7, 4, 9), (1, 3, 5)]
Filtered values : [False, False, True]
Time complexity: O(nm), where n is the length of the input list and m is the length of the tuples in the input list
Auxiliary space: O(n), as it creates a new list res with a length equal to the number of tuples in the input list.
Method #6: Using numpy:
Algorithm:
- Convert the given list of tuples to a NumPy array.
- Create a boolean NumPy array of the same shape as the input array, with all elements initialized to False.
- Compare each element in each row of the input array with its preceding element, using NumPy’s element-wise comparison.
- Replace the first element in each row of the resulting boolean array with False, since there is no preceding element for the first element in each row.
- Return the resulting boolean array as a list of lists.
Python3
import numpy as np
test_list = [(3, 5, 1), (7, 4, 9), (1, 3, 5)]
print("The original list : " + str(test_list))
arr = np.array(test_list)
res = np.hstack((np.zeros((arr.shape[0], 1), dtype=bool), arr[:, 1:] > arr[:, :-1]))
print("Filtered values : " + str(res.tolist()))
|
Output:
The original list : [(3, 5, 1), (7, 4, 9), (1, 3, 5)]
Filtered values : [[False, True, False], [False, False, True], [False, True, True]]
Time Complexity:
Creating a NumPy array from a list takes O(n) time where n is the number of elements in the list.
Comparing each element in each row of the input array with its preceding element using NumPy’s element-wise comparison takes O(m * n) time where m is the number of rows and n is the number of columns in the input array.
Replacing the first element in each row of the resulting boolean array with False takes O(m) time.
Converting the resulting boolean array to a list of lists takes O(m * n) time.
Therefore, the overall time complexity of the algorithm is O(m * n).
Auxiliary Space:
Creating a NumPy array from a list requires O(m * n) space, where m is the number of rows and n is the number of columns in the list of tuples.
Creating a boolean array of the same shape as the input array requires O(m * n) space.
Converting the boolean array to a list of lists requires O(m * n) space.
Therefore, the overall space complexity of the algorithm is O(m * n).
Method #7: Using pandas.DataFrame.diff()
- Convert the list of tuples to a pandas DataFrame using pd.DataFrame().
- Use the .diff() method with axis=1 to calculate the difference between each element in a row and the preceding element.
- Use the .gt() method to check which elements are greater than their preceding element.
- Convert the resulting DataFrame to a list of lists using .values.tolist().
Python3
import pandas as pd
test_list = [(3, 5, 1), (7, 4, 9), (1, 3, 5)]
print("The original list : " + str(test_list))
df = pd.DataFrame(test_list)
diff = df.diff(axis=1)
res = diff.gt(0)
res = res.values.tolist()
print("Filtered values : " + str(res))
|
Output-
The original list : [(3, 5, 1), (7, 4, 9), (1, 3, 5)]
Filtered values : [[False, True, False], [False, False, True], [False, True, True]]
Time complexity: O(nm), where n is the number of rows and m is the number of elements in each row.
Space complexity: O(nm), for the pandas DataFrame and resulting list of lists.
Similar Reads
Python - Extracting Priority Elements in Tuple List
Sometimes, while working with Python Records, we can have a problem in which we need to perform extraction of all the priority elements from records, which usually occur as one of the binary element tuple. This kind of problem can have possible application in web development and gaming domains. Let'
5 min read
Python | Check if element is present in tuple of tuples
Sometimes the data that we use is in the form of tuples and often we need to look into the nested tuples as well. The common problem that this can solve is looking for missing data or na value in data preprocessing. Let's discuss certain ways in which this can be performed. Method #1: Using any() an
4 min read
Python - Test if tuple list has Single element
Given a Tuple list, check if it is composed of only one element, used multiple times. Input : test_list = [(3, 3, 3), (3, 3), (3, 3, 3), (3, 3)] Output : True Explanation : All elements are equal to 3. Input : test_list = [(3, 3, 3), (3, 3), (3, 4, 3), (3, 3)] Output : False Explanation : All elemen
8 min read
Python - Check if any list element is present in Tuple
Given a tuple, check if any list element is present in it. Input : test_tup = (4, 5, 10, 9, 3), check_list = [6, 7, 10, 11] Output : True Explanation : 10 occurs in both tuple and list. Input : test_tup = (4, 5, 12, 9, 3), check_list = [6, 7, 10, 11] Output : False Explanation : No common elements.
6 min read
Python - Check if previous element is smaller in List
Sometimes, while working with Python lists, we can have a problem in which we need to check for each element if its preceding element is smaller. This type of problem can have its use in data preprocessing domains. Let's discuss certain problems in which this task can be performed. Input : test_list
5 min read
Python program to remove last element from Tuple
Given a tuple, the task is to write a Python program to delete the last element in the tuple in Python. Example: Input: ("geeks", "for", "geeks") Output:("geeks", "for") Explanation: Here we are deleting the last element of the tuple and finally modifying the original one. Note: Tuples are immutable
3 min read
Python - Sort by Frequency of second element in Tuple List
Given list of tuples, sort by frequency of second element of tuple. Input : test_list = [(6, 5), (1, 7), (2, 5), (8, 7), (9, 8), (3, 7)] Output : [(1, 7), (8, 7), (3, 7), (6, 5), (2, 5), (9, 8)] Explanation : 7 occurs 3 times as 2nd element, hence all tuples with 7, are aligned first. Input : test_l
6 min read
Swap tuple elements in list of tuples - Python
The task of swapping tuple elements in a list of tuples in Python involves exchanging the positions of elements within each tuple while maintaining the list structure. Given a list of tuples, the goal is to swap the first and second elements in every tuple. For example, with a = [(3, 4), (6, 5), (7,
3 min read
Python - Sort Matrix by Number of elements greater than its previous element
Given a Matrix, sort by occurrences where next element is greater than current. Compute the count of i < i + 1 in each list, sort each row by count of each of this condition in each row. Input : test_list = [[4, 6, 2, 9, 10], [5, 3, 2, 5], [2, 4, 5, 6, 7, 7], [6, 3, 2]] Output : [[6, 3, 2], [5, 3
4 min read
Shift Last Element to First Position in list - Python
The task of shifting the last element to the first position in a list in Python involves modifying the order of elements such that the last item of the list is moved to the beginning while the rest of the list remains intact. For example, given a list a = [1, 4, 5, 6, 7, 8, 9, 12], the goal is to sh
3 min read