Open In App

# Python | How to get unique elements in nested tuple

Sometimes, while working with tuples, we can have a problem in which we have nested tuples and we need to extract elements that occur singly, i.e are elementary. This kind of problem can have applications in many domains. Let’s discuss certain ways in which this problem can be solved.

Method #1: Using nested loop + set()

The above 2 functionalities can be used to solve this particular problem. In this, we iterate each nested tuple and add to the set if the element has occurred for the first time and check for each element before adding.

## Python3

 `# Python3 code to demonstrate working of``# Unique elements in nested tuple``# Using nested loop + set()` `# initialize list``test_list ``=` `[(``3``, ``4``, ``5``), (``4``, ``5``, ``7``), (``1``, ``4``)]` `# printing original list``print``(``"The original list : "` `+` `str``(test_list))` `# Unique elements in nested tuple``# Using nested loop + set()``res ``=` `[]``temp ``=` `set``()``for` `inner ``in` `test_list:``        ``for` `ele ``in` `inner:``            ``if` `not` `ele ``in` `temp:``                ``temp.add(ele)``                ``res.append(ele)` `# printing result``print``(``"Unique elements in nested tuples are : "` `+` `str``(res))`

Output

```The original list : [(3, 4, 5), (4, 5, 7), (1, 4)]
Unique elements in nested tuples are : [3, 4, 5, 7, 1]```

Time Complexity: O(n^2) where n is the total number of elements in the nested tuples. This is because we are using a nested loop to iterate through each inner tuple and then through each element within the inner tuple.
Auxiliary Space: O(n) where n is the total number of elements in the nested tuples. This is because we are using a set to store the unique elements, which takes O(n) space.

Method #2 : Using set() + from_iterable()

The combo of the above functionalities can be used to solve this. This is done is 2 steps, first, we flatten the nested list and then find distinct using set() method.

## Python3

 `# Python3 code to demonstrate working of``# Unique elements in nested tuple``# Using from_iterable() + set()``from` `itertools ``import` `chain` `# initialize list``test_list ``=` `[(``3``, ``4``, ``5``), (``4``, ``5``, ``7``), (``1``, ``4``)]` `# printing original list``print``(``"The original list : "` `+` `str``(test_list))` `# Unique elements in nested tuple``# Using from_iterable() + set()``res ``=` `list``(``set``(chain.from_iterable(test_list)))` `# printing result``print``(``"Unique elements in nested tuples are : "` `+` `str``(res))`

Output

```The original list : [(3, 4, 5), (4, 5, 7), (1, 4)]
Unique elements in nested tuples are : [1, 3, 4, 5, 7]```

Time complexity: O(n), where n is the total number of elements in all the tuples in the input list.
Auxiliary space: O(n), where n is the total number of elements in all the tuples in the input list.

Method #3 : Using list(),extend(),set()

## Python3

 `# Python3 code to demonstrate working of``# Unique elements in nested tuple` `# initialize list``test_list ``=` `[(``3``, ``4``, ``5``), (``4``, ``5``, ``7``), (``1``, ``4``)]` `# printing original list``print``(``"The original list : "` `+` `str``(test_list))` `# Unique elements in nested tuple``x``=``[]``for` `i ``in` `test_list:``    ``i``=``list``(i)``    ``x.extend(i)``res``=``list``(``set``(x))``# printing result``print``(``"Unique elements in nested tuples are : "` `+` `str``(res))`

Output

```The original list : [(3, 4, 5), (4, 5, 7), (1, 4)]
Unique elements in nested tuples are : [1, 3, 4, 5, 7]```

Method #4 : Using Counter() function

## Python3

 `# Python3 code to demonstrate working of``# Unique elements in nested tuple``from` `collections ``import` `Counter``# initialize list``test_list ``=` `[(``3``, ``4``, ``5``), (``4``, ``5``, ``7``), (``1``, ``4``)]` `# printing original list``print``(``"The original list : "` `+` `str``(test_list))` `# Unique elements in nested tuple``x ``=` `[]``for` `i ``in` `test_list:``    ``x.extend(``list``(i))``freq ``=` `Counter(x)``res ``=` `list``(freq.keys())``res.sort()``# printing result``print``(``"Unique elements in nested tuples are : "` `+` `str``(res))`

Output

```The original list : [(3, 4, 5), (4, 5, 7), (1, 4)]
Unique elements in nested tuples are : [1, 3, 4, 5, 7]```

Method #5:Using Operator.countOf() method

## Python3

 `# Python3 code to demonstrate working of``# Unique elements in nested tuple` `import` `operator as op``# initialize list``test_list ``=` `[(``3``, ``4``, ``5``), (``4``, ``5``, ``7``), (``1``, ``4``)]` `# printing original list``print``(``"The original list : "` `+` `str``(test_list))` `# Unique elements in nested tuple``# Using nested loop + set()``res ``=` `[]``temp ``=` `set``()``for` `inner ``in` `test_list:``        ``for` `ele ``in` `inner:``            ``if` `op.countOf(temp,ele)``=``=``0``:``                ``temp.add(ele)``                ``res.append(ele)``res.sort()``# printing result``print``(``"Unique elements in nested tuples are : "` `+` `str``(res))`

Output

```The original list : [(3, 4, 5), (4, 5, 7), (1, 4)]
Unique elements in nested tuples are : [1, 3, 4, 5, 7]```

Time Complexity: O(N)
Auxiliary Space: O(N*N)

Method #6: Using a list comprehension and set conversion.

• Initialize a list of tuples test_list containing three nested tuples with integer elements.
• Print the original list test_list using the print() function with a string concatenated with the list.
• Create a list comprehension using nested for loops to iterate over each element inner in test_list and then each element x in inner. The resulting list is flattened from the nested tuples into a 1D list.
• Convert the resulting list into a set using set(), which removes any duplicates in the list.
• Sort the resulting set using sorted() to order the unique elements.
• Assign the resulting list to a variable res.
• Print the unique elements in nested tuples by concatenating a string with the variable res converted into a string using str().

## Python3

 `# Python3 code to demonstrate working of``# Unique elements in nested tuple` `# initialize list``test_list ``=` `[(``3``, ``4``, ``5``), (``4``, ``5``, ``7``), (``1``, ``4``)]` `# printing original list``print``(``"The original list : "` `+` `str``(test_list))` `# Unique elements in nested tuple``# Using list comprehension and set conversion``res ``=` `sorted``(``set``([x ``for` `inner ``in` `test_list ``for` `x ``in` `inner]))` `# printing result``print``(``"Unique elements in nested tuples are : "` `+` `str``(res))`

Output

```The original list : [(3, 4, 5), (4, 5, 7), (1, 4)]
Unique elements in nested tuples are : [1, 3, 4, 5, 7]```

Time complexity: O(n), where n is the total number of elements in the nested tuples, as it involves iterating over each element once using itertools.chain.
Auxiliary space: O(n), as we are creating a list to store the unique elements, and the size of the list can be at most n, where n is the total number of elements in the nested tuples.

Method #7: Using numpy.unique() function

Step-by-step approach:

• Import the numpy module.
• Initialize the list of tuples.
• Use numpy.concatenate() to flatten the nested tuples into a single array.
• Use numpy.unique() to get unique elements in the flattened array.
• Convert the result into a list and sort it.
• Print the sorted list of unique elements.

## Python3

 `# Python3 code to demonstrate working of``# Unique elements in nested tuple` `# import numpy module``import` `numpy as np` `# initialize list``test_list ``=` `[(``3``, ``4``, ``5``), (``4``, ``5``, ``7``), (``1``, ``4``)]` `# printing original list``print``(``"The original list : "` `+` `str``(test_list))` `# Unique elements in nested tuple``# Using numpy.unique() function``res ``=` `np.unique(np.concatenate(test_list)).tolist()` `# printing result``print``(``"Unique elements in nested tuples are : "` `+` `str``(res))`

```OUTPUT :
The original list : [(3, 4, 5), (4, 5, 7), (1, 4)]
Unique elements in nested tuples are : [1, 3, 4, 5, 7]```

Time complexity: O(NlogN), where N is the total number of elements in all tuples.
Auxiliary space: O(N), where N is the total number of elements in all tuples.