Python – Unique Kth positioned tuples

Sometimes, while working with Python records, we can have a problem in which we need to extract only the unique tuples, based on some particular index of tuples. This kind of problem can have applications in domains such as web development. Let’s discuss certain ways in which this task can be performed.

Input : test_list = [(5, 6, 5), (4, 2, 7), (1, 2, 3), (9, 6, 5)] K = 3 
Output : [(1, 2, 3), (5, 6, 5), (4, 2, 7)] 

Input : test_list = [(5, ), (1, ), (1, ), (9, )] K = 1 
Output : [(1, ), (5, ), (9, )]

Method #1 : Using map() + next() + lambda The combination of above functions can be used to solve this problem. In this, we extend the logic of getting unique elements extracted using lambda function and next(), using map(). 

The original list is : [(5, 6, 8), (4, 2, 7), (1, 2, 3), (9, 6, 5)]
The extracted elements : [(4, 2, 7), (5, 6, 8)]

Time Complexity: O(n*n) where n is the number of elements in the in the list “test_list”. The map() + next() + lambda is used to perform the task and it takes O(n*n) time.
Auxiliary Space: O(n), the algorithm uses an additional list to store the result, thus consuming linear space which is O(n).

Method #2 : Using next() + groupby() + lambda The combination of above functions can also be used to solve this problem. In this, we perform task of map() in above using groupby(), in a more compact way. 

The original list is : [(5, 6, 8), (4, 2, 7), (1, 2, 3), (9, 6, 5)]
The extracted elements : [(4, 2, 7), (5, 6, 8)]

Time Complexity: O(n*logn), where n is the length of the input list test_list. 
Auxiliary Space: O(n)

Method #3 : Using loops ,in and not in operators 

The original list is : [(5, 6, 8), (4, 2, 7), (1, 2, 3), (9, 6, 5)]
The extracted elements : [(5, 6, 8), (4, 2, 7)]

Time complexity: O(n^2) in the worst case, where n is the length of the input list
Auxiliary space: O(n) for the list a and the result list res, where n is the length of the input list.

Method 4: Using a set and a list comprehension

1. Create an empty set unique_set.
2. Create an empty list res.
3. Iterate through each tuple tup in the test_list.
4. Check if the Kth element of tup is in unique_set.
5. If it is not in unique_set, add it to unique_set and append tup to res.
6. If it is already in unique_set, do nothing.
7. Print the list res.

The original list is : [(5, 6, 8), (4, 2, 7), (1, 2, 3), (9, 6, 5)]
The extracted elements : [(5, 6, 8), (4, 2, 7)]

Time complexity: O(n), where n is the length of test_list.
Auxiliary space: O(n), where n is the length of test_list.

Method #5: Using a dictionary and a loop

Step-by-step approach:

• Create an empty dictionary unique_dict to store unique elements.
• Loop through the list of tuples test_list.
  • Check if the K-th index element of the tuple is already in the unique_dict.
  • If it is not in the dictionary, add it to the dictionary and append the tuple to the result list res.
  • If it is already in the dictionary, do not append the tuple to the result list.
• Return the result list res.

Below is the implementation of the above approach:

The original list is : [(5, 6, 8), (4, 2, 7), (1, 2, 3), (9, 6, 5)]
The extracted elements : [(5, 6, 8), (4, 2, 7)]

Time complexity: O(n), where n is the length of the test_list.
Auxiliary space: O(n), to store the dictionary unique_dict.

Method #6: Using reduce():

Algorithm:

1. Initialize the input list test_list and K.
2. Define an empty dictionary unique_dict and an empty list res to store unique tuples.
3. Loop through each tuple in the test_list.
4. Check whether the Kth index element of the current tuple is already in the unique_dict.
5. If not, add the Kth index element to the unique_dict and append the current tuple to the res list.
6. Return the res list as the result.
7. Print the result.

The original list is : [(5, 6, 8), (4, 2, 7), (1, 2, 3), (9, 6, 5)]
The extracted elements : [(5, 6, 8), (4, 2, 7)]

Time Complexity: O(n), where n is the length of the input list.
The time complexity of the for loop is O(n) and the time complexity of the dictionary lookups and list append operations inside the loop is O(1).

Space Complexity: O(n), where n is the length of the input list.
The space complexity is dominated by the dictionary unique_dict and the list res, which can each potentially store up to n elements.

Method #7 : Using filter() and lambda function

• We can use the filter() function along with a lambda function to filter out tuples whose Kth index value is not unique
• In the lambda function, we create a set of all the Kth index values seen so far and check if the current tuple’s Kth index value is already in the set or not
• If it is not in the set, we add it to the set and return True to keep the tuple in the filtered list
• If it is already in the set, we return False to filter it out
• Finally, we convert the filtered result to a list using the list() function.

The original list is : [(5, 6, 8), (4, 2, 7), (1, 2, 3), (9, 6, 5)]
The extracted elements : [(5, 6, 8), (4, 2, 7)]

Time complexity: O(n)
Auxiliary space: O(n) for the set to keep track of unique Kth index values.