Open In App
Related Articles

Python – Remove Similar Rows from Tuple Matrix

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Sometimes, while working with Tuple Matrix, we can have a problem in which we get lots of data, which are similar, i.e elements are same in rows, just the ordering of tuples is different, it’s sometimes, desired to get them removed. This kind of problem can have application in domains such as web development and day-day programming. Let’s discuss certain ways in which this task can be performed.

Input : test_list = [[(4, 5), (3, 2)], [(3, 2), (4, 5)], [(3, 2), (4, 5)]] 
Output : {((4, 5), (3, 2))} 

Input : test_list = [[(4, 6), (3, 2)], [(3, 2), (4, 5)], [(3, 2), (4, 5)]] 
Output : {((3, 2), (4, 6)), ((4, 5), (3, 2))}

Method #1: Using set() + tuple() + sorted() + list comprehension The combination of above functions can be used to solve this problem. In this, we first, perform the sorting, and then convert the rows to set, which automatically removes the duplicates. 

Python3

# Python3 code to demonstrate working of
# Remove Similar Rows from Tuple Matrix
# Using set() + tuple() + sorted() + list comprehension
 
# initializing lists
test_list = [[(4, 5), (3, 2)], [(2, 2), (4, 6)], [(3, 2), (4, 5)]]
 
# printing original list
print("The original list is : " + str(test_list))
 
# Remove Similar Rows from Tuple Matrix
# Using set() + tuple() + sorted() + list comprehension
res = set([tuple(set(sub)) for sub in test_list])
 
# printing result
print("Tuple matrix after removal : " + str(res))

                    
Output : 
The original list is : [[(4, 5), (3, 2)], [(2, 2), (4, 6)], [(3, 2), (4, 5)]]
Tuple matrix after removal : {((4, 6), (2, 2)), ((4, 5), (3, 2))}

Time Complexity: O(n), where n is the length of the list test_dict
Auxiliary Space: O(n) additional space of size n is created where n is the number of elements in the res list

Method #1: Using set() + tuple() + sorted() + list comprehension The combination of above functions can be used to solve this problem. In this, we perform the task of sorting and tuple conversion using frozenset(). 

Python3

# Python3 code to demonstrate working of
# Remove Similar Rows from Tuple Matrix
# Using set() + frozenset() + generator expression
 
# initializing lists
test_list = [[(4, 5), (3, 2)], [(2, 2), (4, 6)], [(3, 2), (4, 5)]]
 
# printing original list
print("The original list is : " + str(test_list))
 
# Remove Similar Rows from Tuple Matrix
# Using set() + frozenset() + generator expression
res = set([frozenset(sub) for sub in test_list])
 
# printing result
print("Tuple matrix after removal : " + str(res))

                    
Output : 
The original list is : [[(4, 5), (3, 2)], [(2, 2), (4, 6)], [(3, 2), (4, 5)]]
Tuple matrix after removal : {frozenset({(4, 5), (3, 2)}), frozenset({(4, 6), (2, 2)})}

Method #3 : Using dict + tuple() + list 

  • Convert each sublist in the matrix to a tuple so that we can use it as a dictionary key later.
  • Create an empty dictionary to store the unique tuples.
  • Loop through each tuple in the matrix and check if it exists in the dictionary.
  • If it doesn’t exist, add it to the dictionary.
  • Convert the dictionary values back to tuples and return the set of unique tuples.

Python3

def remove_similar_rows(matrix):
    # convert each sublist in the matrix to a tuple
    tuples = [tuple(row) for row in matrix]
 
    # create an empty dictionary
    seen = {}
 
    # iterate over the tuples
    for tup in tuples:
        # use the sorted tuple as a key to avoid issues with tuple order
        key = tuple(sorted(tup))
        # add the tuple to the dictionary if it hasn't been seen before
        if key not in seen:
            seen[key] = tup
 
    # return the values (i.e. unique tuples) of the dictionary as a list
    return list(seen.values())
 
# test the function with the same input matrices as before
test_list = [[(4, 5), (3, 2)], [(3, 2), (4, 5)], [(3, 2), (4, 5)]]
print(remove_similar_rows(test_list))  # output: [((4, 5), (3, 2))]
 
test_list = [[(4, 6), (3, 2)], [(3, 2), (4, 5)], [(3, 2), (4, 5)]]
print(remove_similar_rows(test_list))  # output: [((3, 2), (4, 5)), ((4, 6), (3, 2))]

                    

Output
[((4, 5), (3, 2))]
[((4, 6), (3, 2)), ((3, 2), (4, 5))]

Time complexity: O(n)
Auxiliary Space: O(n)

Method #4:  Using the numpy library to remove duplicates:

Algorithm:

1.Initialize the input list test_list.
2.Convert the list to a numpy array using np.array().
3.Use the numpy’s unique() function to remove duplicates by specifying the axis as 0.
4.Convert the numpy array back to a list using tolist() function.
5.Print the unique list.

Python3

import numpy as np
 
# initializing lists
test_list = [[(4, 6), (3, 2)], [(3, 2), (4, 5)], [(3, 2), (4, 5)]]
 
# convert the list to a numpy array
arr = np.array(test_list)
 
# use numpy's unique() function to remove duplicates
unique_arr = np.unique(arr, axis=0)
 
# convert the numpy array back to a list of lists
unique_list = unique_arr.tolist()
 
# print the unique list
print(unique_list)
#This code is contributed by Jyothi pinjala

                    

Output:

The original list is : [[(4, 6), (3, 2)], [(3, 2), (4, 5)], [(3, 2), (4, 5)]]
[[[3, 2], [4, 5]], [[4, 6], [3, 2]]]


Time complexity:
The time complexity of this algorithm is O(n log n), where n is the number of elements in the input list. The reason for this is that the np.unique() function uses sorting algorithms to find the unique elements, which takes O(n log n) time in the worst-case scenario.

Space complexity:
The space complexity of this algorithm is O(n), where n is the number of elements in the input list. This is because we are creating a numpy array and a list of the same size as the input list to store the unique elements.

Method 5: Using a loop to iterate over each tuple and checking if it has already been added to the unique list using a separate list.

Step-by-step approach:

  • Initialize an empty list unique_list to store the unique tuples.
  • Initialize an empty list seen to keep track of the tuples that have been seen already.
  • Loop through each tuple in the original list test_list.
  • If the tuple is not in the seen list, add it to both unique_list and seen.
  • Print the unique_list.

Below is the implementation of the above approach:

Python3

# initializing lists
test_list = [[(4, 6), (3, 2)], [(3, 2), (4, 5)], [(3, 2), (4, 5)]]
 
# initialize an empty list to store unique tuples
unique_list = []
 
# initialize an empty list to keep track of seen tuples
seen = []
 
# loop through each tuple in the original list
for tpl in test_list:
    # if the tuple has not been seen yet, add it to the unique list and seen list
    if tpl not in seen:
        unique_list.append(tpl)
        seen.append(tpl)
 
# print the unique list
print(unique_list)

                    

Output
[[(4, 6), (3, 2)], [(3, 2), (4, 5)]]

Time complexity: O(n^2), where n is the length of the original list.
Auxiliary space: O(n), as we need to store the seen list.

Method#6: Using Recursive method.

Algorithm:

1. Initialize an empty list to store unique tuples
2. Initialize an empty list to keep track of seen tuples
3. Loop through each tuple in the original list:
    a. If the tuple has not been seen yet, add it to the unique list and seen list
4. Return the unique list

Python3

def remove_duplicates_recursive(lst, unique_lst=[], seen=[]):
    # base case: the list is empty
    if not lst:
        return unique_lst
    # check if the first tuple in the list has already been seen
    elif lst[0] not in seen:
        # if not, add it to the unique list and seen list
        unique_lst.append(lst[0])
        seen.append(lst[0])
    # recursively call the function with the rest of the list
    return remove_duplicates_recursive(lst[1:], unique_lst, seen)
test_list = [[(4, 6), (3, 2)], [(3, 2), (4, 5)], [(3, 2), (4, 5)]]
unique_list = remove_duplicates_recursive(test_list)
print(unique_list)

                    

Output
[[(4, 6), (3, 2)], [(3, 2), (4, 5)]]

Time complexity:
– The loop iterates through each tuple in the list once, giving us a time complexity of O(n), where n is the length of the list.
– The `if` statement inside the loop has a time complexity of O(1).
– Therefore, the overall time complexity of the algorithm is O(n).

Space complexity:
– We create two lists to store unique tuples and seen tuples, respectively, so the space complexity of the algorithm is O(n), where n is the length of the list.

Method#7: Using heapq:

Algorithm:

  1. Initialize the input list
  2. Convert the list to a numpy array
  3. Use numpy’s unique() function to remove duplicates
  4. Convert the numpy array back to a list of lists
  5. Print the unique list

Python3

import heapq
 
# initializing lists
test_list = [[(4, 6), (3, 2)], [(3, 2), (4, 5)], [(3, 2), (4, 5)]]
# printing original list
print("The original list is : " + str(test_list))
# create a set of tuples from the original list
tuple_set = set(map(tuple, test_list))
 
# convert the set back to a list of lists
unique_list = [list(t) for t in tuple_set]
 
# print the unique list
print(unique_list)
#This code is contributed by Rayudu.

                    

Output
The original list is : [[(4, 6), (3, 2)], [(3, 2), (4, 5)], [(3, 2), (4, 5)]]
[[(3, 2), (4, 5)], [(4, 6), (3, 2)]]

Time complexity:
The time complexity of this algorithm is O(n log n), where n is the number of elements in the input list. This is because the numpy unique() function uses a sorting algorithm, which has a time complexity of O(n log n).

Auxiliary Space:
The space complexity of this algorithm is O(n), where n is the number of elements in the input list. This is because we are converting the input list to a numpy array, which takes up space in memory. Additionally, the numpy unique() function creates a new array to store the unique elements, which also takes up space in memory. Finally, we convert the numpy array back to a list of lists, which also takes up space in memory.



Last Updated : 27 Apr, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads