# Python | Program to count duplicates in a list of tuples

• Last Updated : 29 Dec, 2022

Given a list of tuples, write a Python program to check if an element of the list has duplicates. If duplicates exist, print the number of occurrences of each duplicate tuple, otherwise print “No Duplicates”.

Examples:

```Input  : [('a', 'e'), ('b', 'x'), ('b', 'x'), ('a', 'e'), ('b', 'x')]
Output : ('a', 'e') - 2 ('b', 'x') - 3

Input  : [(0, 5), (6, 9), (0, 8)]
Output : No Duplicates```

Let’s see the various ways we can count duplicates in a list of tuples.

Approach #1: Naive Approach This approach uses two loops to traverse the list of elements and check if the first element and second element of each element match any other tuple.

## Python3

 `# Python3 code to convert tuple``# into string`  `def` `count(listOfTuple):` `    ``flag ``=` `False` `    ``# To append Duplicate elements in list``    ``coll_list ``=` `[]``    ``coll_cnt ``=` `0``    ``for` `t ``in` `listOfTuple:` `        ``# To check if Duplicate exist``        ``if` `t ``in` `coll_list:``            ``flag ``=` `True``            ``continue` `        ``else``:``            ``coll_cnt ``=` `0``            ``for` `b ``in` `listOfTuple:``                ``if` `b[``0``] ``=``=` `t[``0``] ``and` `b[``1``] ``=``=` `t[``1``]:``                    ``coll_cnt ``=` `coll_cnt ``+` `1` `            ``# To print count if Duplicate of element exist``            ``if``(coll_cnt & gt``               ``1``):``                ``print``(t, & quot``                      ``-` `", coll_cnt)``            ``coll_list.append(t)` `    ``if` `flag ``=``=` `False``:``        ``print``(& quot``               ``No Duplicates & quot``               ``)`  `# Driver code``print``(& quot``       ``Test Case ``1``: & quot``       ``)``listOfTuple ``=` `[(``'a'``, ``'e'``), (``'b'``, ``'x'``), (``'b'``, ``'x'``),``               ``(``'a'``, ``'e'``), (``'b'``, ``'x'``)]` `count(listOfTuple)` `print``(& quot``       ``Test Case ``2``: & quot``       ``)``listOfTuple ``=` `[(``0``, ``5``), (``6``, ``9``), (``0``, ``8``)]``count(listOfTuple)`

Output:

```Test Case 1:
('a', 'e') - 2
('b', 'x') - 3

Test Case 2:
No Duplicates```

Time complexity – O(n)2

Approach #2: Using Counter is a container included in the collections module. It is an unordered collection where elements and their respective count are stored as dictionary.

## Python3

 `# Python3 code to convert tuple``# into string``import` `collections`  `def` `count(listOfTuple):` `    ``flag ``=` `False``    ``val ``=` `collections.Counter(listOfTuple)``    ``uniqueList ``=` `list``(``set``(listOfTuple))` `    ``for` `i ``in` `uniqueList:``        ``if` `val[i] & gt``        ``=` `2``:``            ``flag ``=` `True``            ``print``(i, & quot``                  ``-` `", val[i])` `    ``if` `flag ``=``=` `False``:``        ``print``(& quot``               ``Duplicate doesn't exist & quot``               ``)`  `# Driver code``listOfTuple ``=` `[(``'a'``, ``'e'``), (``'b'``, ``'x'``), (``'b'``, ``'x'``),``               ``(``'a'``, ``'e'``), (``'b'``, ``'x'``)]``count(listOfTuple)`

Output:

```('b', 'x') - 3
('a', 'e') - 2```

Time complexity – O(n)

Approach #3: Using another dict You can make a dictionary, say count_map, and store the count of each tuple as the value.

## Python3

 `# Python3 code to convert tuple``# into string`  `def` `count(listOfTuple):` `    ``count_map ``=` `{}``    ``for` `i ``in` `listOfTuple:``        ``count_map[i] ``=` `count_map.get(i, ``0``) ``+` `1``    ``print``(count_map)`  `# Driver code``print``( & quot``      ``Test Case ``1``: & quot``      ``)``listOfTuple ``=` `[(``'a'``, ``'e'``), (``'b'``, ``'x'``), (``'b'``, ``'x'``),``               ``(``'a'``, ``'e'``), (``'b'``, ``'x'``)]` `count(listOfTuple)`

Output:

```Test Case 1:
{('a', 'e'): 2, ('b', 'x'): 3}```

Time complexity – O(n)

Approach #4:  Using collections

Another approach to count duplicates in a list of tuples is to use a Counter object from the collections module. You can pass the list of tuples to the Counter constructor and it will create a dictionary-like object that stores the count of each tuple. Then, you can iterate over the Counter object and print out the tuple and its count if the count is greater than 1.

Here is an example of how you could implement this approach:

## Python3

 `from` `collections ``import` `Counter` `def` `count_duplicates(lst):``    ``counter ``=` `Counter(lst)``    ``for` `tup, count ``in` `counter.items():``        ``if` `count > ``1``:``            ``print``(f``"{tup}: {count}"``)``    ``if` `not` `any``(count > ``1` `for` `count ``in` `counter.values()):``        ``print``(``"No Duplicates"``)` `# Example usage``lst ``=` `[(``'a'``, ``'e'``), (``'b'``, ``'x'``), (``'b'``, ``'x'``), (``'a'``, ``'e'``), (``'b'``, ``'x'``)]``count_duplicates(lst)  ``# prints ('a', 'e'): 2, ('b', 'x'): 3` `lst ``=` `[(``0``, ``5``), (``6``, ``9``), (``0``, ``8``)]``count_duplicates(lst)  ``# prints No Duplicates``#This code is contributed by Edula Vinay Kumar Reddy`

Output

```('a', 'e'): 2
('b', 'x'): 3
No Duplicates```

This approach has a time complexity of O(n), where n is the length of the input list, because it involves one pass through the list of tuples to create the Counter object and another pass through the Counter object to print the output. The space complexity is also O(n), because the Counter object stores a count for each tuple in the input list.

My Personal Notes arrow_drop_up