 GeeksforGeeks App
Open App Browser
Continue

# Python | Program to print duplicates from a list of integers

Given a list of integers with duplicate elements in it. The task is to generate another list, which contains only the duplicate elements. In simple words, the new list should contain elements that appear as more than one.

Examples:

```Input : list = [10, 20, 30, 20, 20, 30, 40, 50, -20, 60, 60, -20, -20]
Output : output_list = [20, 30, -20, 60]```
```Input :  list = [-1, 1, -1, 8]
Output : output_list = [-1]```

## Python3

 `# Python program to print``# duplicates from a list``# of integers``def` `Repeat(x):``    ``_size ``=` `len``(x)``    ``repeated ``=` `[]``    ``for` `i ``in` `range``(_size):``        ``k ``=` `i ``+` `1``        ``for` `j ``in` `range``(k, _size):``            ``if` `x[i] ``=``=` `x[j] ``and` `x[i] ``not` `in` `repeated:``                ``repeated.append(x[i])``    ``return` `repeated` `# Driver Code``list1 ``=` `[``10``, ``20``, ``30``, ``20``, ``20``, ``30``, ``40``,``         ``50``, ``-``20``, ``60``, ``60``, ``-``20``, ``-``20``]``print` `(Repeat(list1))``    ` `# This code is contributed``# by Sandeep_anand`

Output

`[20, 30, -20, 60]`

Time complexity: O(n^2) where n is the length of the input list
Auxiliary space: O(k) where k is the number of duplicates in the input list.

## Python3

 `# Python program to print duplicates from``# a list of integers``lis ``=` `[``1``, ``2``, ``1``, ``2``, ``3``, ``4``, ``5``, ``1``, ``1``, ``2``, ``5``, ``6``, ``7``, ``8``, ``9``, ``9``]` `uniqueList ``=` `[]``duplicateList ``=` `[]` `for` `i ``in` `lis:``    ``if` `i ``not` `in` `uniqueList:``        ``uniqueList.append(i)``    ``elif` `i ``not` `in` `duplicateList:``        ``duplicateList.append(i)` `print``(duplicateList)`

Output

`[1, 2, 5, 9]`

Time Complexity: O(n)
Auxiliary Space: O(n)

## Python3

 `from` `collections ``import` `Counter` `l1 ``=` `[``1``,``2``,``1``,``2``,``3``,``4``,``5``,``1``,``1``,``2``,``5``,``6``,``7``,``8``,``9``,``9``]``d ``=` `Counter(l1)``print``(d)` `new_list ``=` `list``([item ``for` `item ``in` `d ``if` `d[item]>``1``])``print``(new_list)`

Output

```Counter({1: 4, 2: 3, 5: 2, 9: 2, 3: 1, 4: 1, 6: 1, 7: 1, 8: 1})
[1, 2, 5, 9]```

Time Complexity: O(n)
Auxiliary Space: O(n)

## Python3

 `# program to print duplicate numbers in a given list``# provided input``list` `=` `[``1``, ``2``, ``1``, ``2``, ``3``, ``4``, ``5``, ``1``, ``1``, ``2``, ``5``, ``6``, ``7``, ``8``, ``9``, ``9``]` `new ``=` `[]  ``# defining output list` `# condition for reviewing every``# element of given input list``for` `a ``in` `list``:` `     ``# checking the occurrence of elements``    ``n ``=` `list``.count(a)` `    ``# if the occurrence is more than``    ``# one we add it to the output list``    ``if` `n > ``1``:` `        ``if` `new.count(a) ``=``=` `0``:  ``# condition to check` `            ``new.append(a)` `print``(new)` `# This code is contributed by Himanshu Khune`

Output

`[1, 2, 5, 9]`

## Python3

 `def` `duplicate(input_list):``    ``return` `list``(``set``([x ``for` `x ``in` `input_list ``if` `input_list.count(x) > ``1``]))` `if` `__name__ ``=``=` `'__main__'``:``    ``input_list ``=` `[``1``, ``2``, ``1``, ``2``, ``3``, ``4``, ``5``, ``1``, ``1``, ``2``, ``5``, ``6``, ``7``, ``8``, ``9``, ``9``]``    ``print``(duplicate(input_list))` `# This code is contributed by saikot`

Output

`[1, 2, 5, 9]`

## Python3

 `def` `duplicate(input_list):``    ``new_dict, new_list ``=` `{}, []` `    ``for` `i ``in` `input_list:``        ``if` `not` `i ``in` `new_dict:``            ``new_dict[i] ``=` `1``        ``else``:``            ``new_dict[i] ``+``=` `1` `    ``for` `key, values ``in` `new_dict.items():``        ``if` `values > ``1``:``            ``new_list.append(key)` `    ``return` `new_list` `if` `__name__ ``=``=` `'__main__'``:``    ``input_list ``=` `[``1``, ``2``, ``1``, ``2``, ``3``, ``4``, ``5``, ``1``, ``1``, ``2``, ``5``, ``6``, ``7``, ``8``, ``9``, ``9``]``    ``print``(duplicate(input_list))` `# This code is contributed by saikot`

Output

`[1, 2, 5, 9]`

## Python3

 `lis ``=` `[``1``, ``2``, ``1``, ``2``, ``3``, ``4``, ``5``, ``1``, ``1``, ``2``, ``5``, ``6``, ``7``, ``8``, ``9``, ``9``]``x ``=` `[]``y ``=` `[]``for` `i ``in` `lis:``    ``if` `i ``not` `in` `x:``        ``x.append(i)``for` `i ``in` `x:``    ``if` `lis.count(i) > ``1``:``        ``y.append(i)``print``(y)`

Output

`[1, 2, 5, 9]`

## Python3

 `input_list ``=` `[``1``, ``2``, ``1``, ``2``, ``3``, ``4``, ``5``, ``1``, ``1``, ``2``, ``5``, ``6``, ``7``, ``8``, ``9``, ``9``]``print``(``list``(``set``([x ``for` `i,x ``in` `enumerate``(input_list) ``if` `input_list.count(x) > ``1``])))`

Output

`[1, 2, 5, 9]`

Time Complexity: O(n)

Auxiliary Space: O(1)

Method 9: Using operator.countOf() method

## Python3

 `import` `operator as op``# program to print duplicate numbers in a given list``# provided input``list` `=` `[``1``, ``2``, ``1``, ``2``, ``3``, ``4``, ``5``, ``1``, ``1``, ``2``, ``5``, ``6``, ``7``, ``8``, ``9``, ``9``]` `new ``=` `[]  ``# defining output list` `# condition for reviewing every``# element of given input list``for` `a ``in` `list``:` `     ``# checking the occurrence of elements``    ``n ``=` `op.countOf(``list``, a)` `    ``# if the occurrence is more than``    ``# one we add it to the output list``    ``if` `n > ``1``:` `        ``if` `op.countOf(new, a) ``=``=` `0``:  ``# condition to check` `            ``new.append(a)` `print``(new)` `# This code is contributed by vikkycirus`

Output

`[1, 2, 5, 9]`

Time Complexity: O(n)
Auxiliary Space: O(1)

## Python3

 `lis ``=` `[``1``, ``2``, ``1``, ``2``, ``3``, ``4``, ``5``, ``1``, ``1``, ``2``, ``5``, ``6``, ``7``, ``8``, ``9``, ``9``]``x ``=` `[]``y ``=` `[]``import` `operator``for` `i ``in` `lis:``    ``if` `i ``not` `in` `x:``        ``x.append(i)``for` `i ``in` `x:``    ``if` `operator.countOf(lis,i) > ``1``:``        ``y.append(i)``print``(y)`

Output

`[1, 2, 5, 9]`

Time Complexity: O(n)
Auxiliary Space: O(n)

Method 11 : Using numpy:

Algorithm:

1. Initialize the list l1 with some values.
2. Import the numpy library.
3. Use numpy.unique() to get the unique values and their counts in the list l1.
4. Use numpy.where() to get the indices of the elements in the counts array that are greater than 1.
5. Use these indices to get the corresponding elements from the unique array.

## Python3

 `import` `numpy as np` `l1 ``=` `[``1``,``2``,``1``,``2``,``3``,``4``,``5``,``1``,``1``,``2``,``5``,``6``,``7``,``8``,``9``,``9``]` `unique, counts ``=` `np.unique(l1, return_counts``=``True``)``new_list ``=` `unique[np.where(counts > ``1``)]` `print``(new_list)``#This code is contributed by Rayudu`

```Output:
[1 2 5 9]```

Time Complexity:

numpy.unique() has a time complexity of O(nlogn) due to the sorting step, where n is the length of the input array.
numpy.where() has a time complexity of O(n), where n is the length of the input array.
Indexing an array takes constant time O(1).
Therefore, the time complexity of this numpy code is O(nlogn), dominated by numpy.unique().

Auxiliary Space:

The space complexity of this numpy code is O(n), since we are storing the input list l1 and the output list new_list.
numpy.unique() and numpy.where() internally create intermediate arrays, but they are not included in the space complexity of this code because they are temporary and not stored in memory.

My Personal Notes arrow_drop_up