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.

def unique(numbers):
    for i in range(len(numbers)):
        for j in range(i+1, len(numbers)):
            if numbers[i] == numbers[j]:
                return i


# print the unique tuple by extracting all the unique elements
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.

# function for iteration and finding unique values
def unique_numbers(numbers):
    un = []
    for num in numbers:
        if num not in un:
            un.append(num)
    # to convert list into tuple using tuple() function
    unique_tuple = tuple(un)
    return unique_tuple


# print the unique tuple by extracting all the unique elements
numbers = (1, 2, 3, 4, 2, 2, 2, 1, 5, 4, 3, 4, 3)
print(unique_numbers(numbers))

(1, 2, 3, 4, 5)

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.

# To find the unique elements from the tuple using the set
def unique_numbers(numbers):
    # this will take only unique numbers from the tuple
    return tuple(set(numbers))


numbers = (1, 2, 3, 4, 'hello', 2, 5, 7, 'hello', 7, 2, 2, 4)
print(unique_numbers(numbers))

(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

from collections import Counter
# To find the unique elements from the tuple using the counter


def unique_numbers(numbers):
    # this will take only unique numbers from the tuple
    return tuple(Counter(numbers).keys())


numbers = (1, 2, 3, 4, 2, 5, 7, 2, 2, 4)
print(unique_numbers(numbers))

(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

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)

(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()

# function for finding unique values
def unique_numbers(numbers):
    un = tuple(j for i, j in enumerate(numbers) if numbers.index(j) == i)
    return un


# print the unique tuple by extracting all the unique elements
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.