Find Unique Elements from Tuple in Python
Tuples are immutable built-in data type in Python that can store multiple values in it. Extracting Unique Elements from a Tuple in Python can be done through two different approaches.
Examples:
Input: (1, 2, 13, 4, 3, 12, 5, 7, 7, 2, 2, 4)
Output: (1, 2, 3,4,5,12,13)
Input: ('Apple', 'Mango', 'Banana', 'Mango', 'Apple')
Output: ('Apple', 'Mango', 'Banana')
Let’s start with the different methods :
By using brute force to get unique elements from tuples
In brute force, we will be using 2 for loops for checking the same values.
Python3
def unique(numbers):
for i in range ( len (numbers)):
for j in range (i + 1 , len (numbers)):
if numbers[i] = = numbers[j]:
return i
numbers = ( 1 , 2 , 3 , 4 , 2 , 2 , 2 , 1 , 5 , 4 , 3 , 4 , 3 )
print (unique_numbers(numbers))
|
Output:
(1, 2, 3, 4, 5)
Time Complexity: O(n^2) for two loops
Auxiliary Space: O(1) as no extra space used
By iterative method to get unique elements from tuples
In this method, a loop can be used to store the unique values in a list and then converting that list into tuple.
Python3
def unique_numbers(numbers):
un = []
for num in numbers:
if num not in un:
un.append(num)
unique_tuple = tuple (un)
return unique_tuple
numbers = ( 1 , 2 , 3 , 4 , 2 , 2 , 2 , 1 , 5 , 4 , 3 , 4 , 3 )
print (unique_numbers(numbers))
|
The time complexity of this function is O(n^2), because the “in” operator in the if statement has a time complexity of O(n) and it’s used n times in the for loop.
The space complexity is O(n), because the maximum space required by the un list is n (when all elements in the input numbers are unique).
By using set data-structure to get unique elements from tuples
As set stores unique values so we use a set to get the unique values from a tuple.
Python3
def unique_numbers(numbers):
return tuple ( set (numbers))
numbers = ( 1 , 2 , 3 , 4 , 'hello' , 2 , 5 , 7 , 'hello' , 7 , 2 , 2 , 4 )
print (unique_numbers(numbers))
|
Output
(1, 2, 3, 4, 5, 7, 'hello')
The time complexity of this function is O(n), because the set() function has a time complexity of O(n) to convert an iterable object into a set object.
The space complexity is also O(n), because the maximum space required by the set object is n (when all elements in the input numbers are unique).
Find Unique Elements from Tuple Using Counter() function
Python3
from collections import Counter
def unique_numbers(numbers):
return tuple (Counter(numbers).keys())
numbers = ( 1 , 2 , 3 , 4 , 2 , 5 , 7 , 2 , 2 , 4 )
print (unique_numbers(numbers))
|
Output
(1, 2, 3, 4, 5, 7)
The time complexity of this function is O(n), because the Counter() function from the collections library has a time complexity of O(n) to count the occurrences of elements in an iterable object.
The space complexity is also O(n), because the maximum space required by the Counter object is n (when all elements in the input numbers are unique).
Find Unique Elements from Tuple Using re module.
The program uses the re module in Python to extract unique elements from a given tuple. It converts the tuple to a string and uses the re.findall() method to extract all the digits from the string as strings. It then uses the map() function to convert the strings to integers and then converts the resulting list to a set to remove duplicates. Finally, it converts the set back to a tuple and prints the result
Python3
import re
numbers = ( 1 , 2 , 3 , 4 , 2 , 5 , 7 , 2 , 2 , 4 )
unique_numbers = tuple ( map ( int , re.findall(r '\d+' , str (numbers))))
unique_numbers = tuple ( set (unique_numbers))
print (unique_numbers)
|
Output
(1, 2, 3, 4, 5, 7)
Time complexity:
The time complexity of the program is O(n) where n is the number of elements in the input tuple. The re.findall() method has a time complexity of O(n) where n is the length of the string, and the set() function has a time complexity of O(n) where n is the number of elements in the input iterable.
Auxiliary Space:
The space complexity of the program is also O(n) where n is the number of elements in the input tuple. This is because the program creates a new list to store the extracted digits as strings, and then creates a new set to remove duplicates before converting back to a tuple. The space used by these data structures is proportional to the number of elements in the input tuple.
Find Unique Elements from Tuple Using Enumeration()
Python
def unique_numbers(numbers):
un = tuple (j for i, j in enumerate (numbers) if numbers.index(j) = = i)
return un
numbers = ( 1 , 2 , 3 , 4 , 2 , 2 , 2 , 1 , 5 , 4 , 3 , 4 , 3 )
print (unique_numbers(numbers))
|
Output:
(1, 2, 3, 4, 5)
Time Complexity: O(N) Where N is the length of the Test tuple.
Auxiliary Space: O(M) Where M is the length of the new Tuple.
Last Updated :
27 Jul, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...