Sometimes we need to find the unique values in a list, which is comparatively easy and has been discussed earlier. But we can also get a matrix as input i.e a list of lists, and finding unique in them are discussed in this article. Let’s see certain ways in which this can be achieved.
Method #1: Using set() + list comprehension The set function can be used to convert the individual list to a non-repeating element list and the list comprehension is used to iterate to each of the lists.
Python3
test_matrix = [[ 1 , 3 , 1 ], [ 4 , 5 , 3 ], [ 1 , 2 , 4 ]]
print ( "The original matrix is : " + str (test_matrix))
res = list ( set (i for j in test_matrix for i in j))
print ( "Unique values in matrix are : " + str (res))
|
Output
The original matrix is : [[1, 3, 1], [4, 5, 3], [1, 2, 4]]
Unique values in matrix are : [1, 2, 3, 4, 5]
Time complexity: O(n^2), where n is the number of elements in the matrix.
Auxiliary space: O(n), where n is the number of unique elements in the matrix.
Method #2: Using chain() + set() The chain function performs the similar task that a list comprehension performs but in a faster way as it uses iterators for its internal processing and hence faster.
Python3
from itertools import chain
test_matrix = [[ 1 , 3 , 1 ], [ 4 , 5 , 3 ], [ 1 , 2 , 4 ]]
print ( "The original matrix is : " + str (test_matrix))
res = list ( set (chain( * test_matrix)))
print ( "Unique values in matrix are : " + str (res))
|
Output
The original matrix is : [[1, 3, 1], [4, 5, 3], [1, 2, 4]]
Unique values in matrix are : [1, 2, 3, 4, 5]
Time Complexity: O(n), where n is the total number of elements in the matrix.
Auxiliary Space: O(n), for storing the unique elements in the set.
Method #3 : Using for loop and extend(),sort() methods
Python3
test_matrix = [[ 1 , 3 , 1 ], [ 4 , 5 , 3 ], [ 1 , 2 , 4 ]]
print ( "The original matrix is : " + str (test_matrix))
x = []
for i in test_matrix:
x.extend(i)
res = []
for i in x:
if i not in res:
res.append(i)
res.sort()
print ( "Unique values in matrix are : " + str (res))
|
Output
The original matrix is : [[1, 3, 1], [4, 5, 3], [1, 2, 4]]
Unique values in matrix are : [1, 2, 3, 4, 5]
Time complexity: O(n*logn), where n is the number of elements in the matrix.
Auxiliary space: O(n), where n is the number of unique elements in the matrix.
Method #4 : Using Counter() function
Python3
from collections import Counter
test_matrix = [[ 1 , 3 , 1 ], [ 4 , 5 , 3 ], [ 1 , 2 , 4 ]]
print ( "The original matrix is : " + str (test_matrix))
x = []
for i in test_matrix:
x.extend(i)
freq = Counter(x)
res = list (freq.keys())
res.sort()
print ( "Unique values in matrix are : " + str (res))
|
Output
The original matrix is : [[1, 3, 1], [4, 5, 3], [1, 2, 4]]
Unique values in matrix are : [1, 2, 3, 4, 5]
Time Complexity:O(N*N)
Auxiliary Space: O(N*N)
Method #5: Using operator.countOf() method
Python3
import operator as op
test_matrix = [[ 1 , 3 , 1 ], [ 4 , 5 , 3 ], [ 1 , 2 , 4 ]]
print ( "The original matrix is : " + str (test_matrix))
x = []
for i in test_matrix:
x.extend(i)
res = []
for i in x:
if op.countOf(res,i) = = 0 :
res.append(i)
res.sort()
print ( "Unique values in matrix are : " + str (res))
|
Output
The original matrix is : [[1, 3, 1], [4, 5, 3], [1, 2, 4]]
Unique values in matrix are : [1, 2, 3, 4, 5]
Time Complexity: O(N*N)
Auxiliary Space: O(N*N)
Method #6:Using groupby()
Python3
import itertools
test_matrix = [[ 1 , 3 , 1 ], [ 4 , 5 , 3 ], [ 1 , 2 , 4 ]]
print ( "The original matrix is : " + str (test_matrix))
flat_list = [item for sublist in test_matrix for item in sublist]
flat_list.sort()
grouped_list = [ list (group) for key, group in itertools.groupby(flat_list)]
res = [group[ 0 ] for group in grouped_list]
print ( "Unique values in matrix are : " + str (res))
|
Output
The original matrix is : [[1, 3, 1], [4, 5, 3], [1, 2, 4]]
Unique values in matrix are : [1, 2, 3, 4, 5]
Time Complexity: O(N*N)
Auxiliary Space: O(N*N)
Method #7: Using numpy.unique() function
Step-by-step approach:
- Import numpy library.
- Initialize the matrix using numpy.array() function.
- Apply numpy.unique() function on the matrix to get the unique values.
- Convert the returned numpy array to a list using the tolist() method.
- Print the list of unique values.
Below is the implementation of the above approach:
Python3
import numpy as np
test_matrix = np.array([[ 1 , 3 , 1 ], [ 4 , 5 , 3 ], [ 1 , 2 , 4 ]])
print ( "The original matrix is : " + str (test_matrix))
res = np.unique(test_matrix).tolist()
print ( "Unique values in matrix are : " + str (res))
|
Output:
The original matrix is : [[1 3 1]
[4 5 3]
[1 2 4]]
Unique values in matrix are : [1, 2, 3, 4, 5]
Time complexity: O(nlogn), where n is the number of elements in the matrix.
Auxiliary space: O(n)
Method #8:Using heapq.merge():
Algorithm
- Import the heapq module.
- Create a NumPy array test_matrix with shape (3, 3) and values [[1, 3, 1], [4, 5, 3], [1, 2, 4]].
- Print the original matrix.
- Use heapq.merge() to merge the rows of test_matrix into a single iterator of sorted elements.
- Convert the iterator to a set to eliminate duplicates.
- Print the unique elements of the matrix.
Python3
import heapq
import numpy as np
test_matrix = np.array([[ 1 , 3 , 1 ], [ 4 , 5 , 3 ], [ 1 , 2 , 4 ]])
print ( "The original matrix is : " + str (test_matrix))
res = set (heapq.merge( * test_matrix))
print ( "Unique values in matrix are : " + str ( list (res)))
|
Output:
The original matrix is : [[1 3 1]
[4 5 3]
[1 2 4]]
Unique values in matrix are : [1, 2, 3, 4, 5]
Time Complexity
The time complexity of the code is determined by the most time-consuming operation, which is heapq.merge(). The time complexity of heapq.merge() is O(k * log(n)), where k is the total number of elements in the matrix and n is the number of rows in the matrix. Therefore, the overall time complexity of the code is O(k * log(n)).
Auxiliary Space
The space complexity of the code is determined by the memory used by the data structures created during the execution of the code. The code creates a NumPy array to store the matrix, which requires O(n^2) space, where n is the number of rows or columns in the array. The heapq.merge() function also creates a heap to store the merged elements, which requires O(k) space, where k is the total number of elements in the matrix. Finally, the code creates a set to store the unique elements, which requires O(k) space. Therefore, the overall space complexity of the code is O(n^2 + k).
Method #9:Using reduce():
Algorithm:
- Initialize the test_matrix variable with a 2D list.
- Print the original matrix using the print() function.
- Import the chain and set functions from the itertools module.
- Use chain() to flatten the 2D matrix into a single list.
- Use set() to get the unique elements from the flattened list.
- Convert the resulting setback to a list using the list() function.
- Print the list of unique values using the print() function.
Below is the implementation of the above approach:
Python3
from functools import reduce
from itertools import chain
test_matrix = [[ 1 , 3 , 1 ], [ 4 , 5 , 3 ], [ 1 , 2 , 4 ]]
print ( "The original matrix is : " + str (test_matrix))
res = list ( reduce ( lambda a, b: set (a) | set (b), test_matrix))
print ( "Unique values in matrix are:" , res)
|
Output
The original matrix is : [[1, 3, 1], [4, 5, 3], [1, 2, 4]]
Unique values in matrix are: [1, 2, 3, 4, 5]
Time Complexity:
- The chain() function is used to flatten the 2D matrix, which takes O(N) time, where N is the total number of elements in the matrix.
- The set() function takes O(N) time to create a set of unique elements.
- Converting the set back to a list using the list() function takes O(N) time.
Therefore, the overall time complexity of the code is O(N).
Space Complexity:
- The test_matrix variable takes O(N) space to store the 2D matrix.
- The res variable takes O(M) space to store the unique elements, where M is the number of unique elements in the matrix.
- The chain() function and the set() function also take O(N) space.
Therefore, the overall space complexity of the code is O(N).
Share your thoughts in the comments
Please Login to comment...