# Find duplicates in O(n) time and O(1) extra space | Set 1

• Difficulty Level : Medium
• Last Updated : 28 May, 2021

Given an array of n elements that contains elements from 0 to n-1, with any of these numbers appearing any number of times. Find these repeating numbers in O(n) and using only constant memory space.

Example:

Become a success story instead of just reading about them. Prepare for coding interviews at Amazon and other top product-based companies with our Amazon Test Series. Includes topic-wise practice questions on all important DSA topics along with 10 practice contests of 2 hours each. Designed by industry experts that will surely help you practice and sharpen your programming skills. Wait no more, start your preparation today!

```Input : n = 7 and array[] = {1, 2, 3, 6, 3, 6, 1}
Output: 1, 3, 6

Explanation: The numbers 1 , 3 and 6 appears more
than once in the array.

Input : n = 5 and array[] = {1, 2, 3, 4 ,3}
Output: 3

Explanation: The number 3 appears more than once
in the array.```

This problem is an extended version of the following problem.
Find the two repeating elements in a given array
Method 1 and Method 2 of the above link are not applicable as the question says O(n) time complexity and O(1) constant space. Also, Method 3 and Method 4 cannot be applied here because there can be more than 2 repeating elements in this problem. Method 5 can be extended to work for this problem. Below is the solution that is similar to Method 5.

Solution 1:

• Approach:The elements in the array is from 0 to n-1 and all of them are positive. So to find out the duplicate elements, a HashMap is required, but the question is to solve the problem in constant space. There is a catch, the array is of length n and the elements are from 0 to n-1 (n elements). The array can be used as a HashMap.
Problem in the below approach. This approach only works for arrays having at most 2 duplicate elements i.e It will not work if the array contains more than 2 duplicates of an element. For example: {1, 6, 3, 1, 3, 6, 6} it will give output as : 1 3 6 6.
• Note: The above program doesn’t handle 0 cases (If 0 is present in array). The program can be easily modified to handle that also. It is not handled to keep the code simple. (Program can be modified to handle 0 cases by adding plus One(+1) to all the values. also subtracting One from the answer and by writing { arr [abs(arr[i]) – 1] } in code)

In other approaches below, solutions are discussed that prints repeating elements only once.
Algorithm:

1. Traverse the array from start to end.
2. For every element,take its absolute value and if the abs(array[i])‘th element is positive, the element has not encountered before, else if negative the element has been encountered before print the absolute value of the current element.

Implementation:

## C++

 `// C++ code to find``// duplicates in O(n) time``#include ``using` `namespace` `std;` `// Function to print duplicates``void` `printRepeating(``int` `arr[], ``int` `size)``{``    ``int` `i;``    ``cout << ``"The repeating elements are:"` `<< endl;``    ``for` `(i = 0; i < size; i++) {``        ``if` `(arr[``abs``(arr[i])] >= 0)``            ``arr[``abs``(arr[i])] = -arr[``abs``(arr[i])];``        ``else``            ``cout << ``abs``(arr[i]) << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 2, 3, 1, 3, 6, 6 };``    ``int` `arr_size = ``sizeof``(arr) / ``sizeof``(arr);``    ``printRepeating(arr, arr_size);``    ``return` `0;``}` `// This code is contributed``// by Akanksha Rai`

## C

 `// C code to find``// duplicates in O(n) time``#include ``#include ` `// Function to print duplicates``void` `printRepeating(``int` `arr[], ``int` `size)``{``    ``int` `i;``    ``printf``(``"The repeating elements are: \n"``);``    ``for` `(i = 0; i < size; i++) {``        ``if` `(arr[``abs``(arr[i])] >= 0)``            ``arr[``abs``(arr[i])] = -arr[``abs``(arr[i])];``        ``else``            ``printf``(``" %d "``, ``abs``(arr[i]));``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 2, 3, 1, 3, 6, 6 };``    ``int` `arr_size = ``sizeof``(arr) / ``sizeof``(arr);``    ``printRepeating(arr, arr_size);``    ``getchar``();``    ``return` `0;``}`

## Java

 `// Java code to find``// duplicates in O(n) time` `class` `FindDuplicate {``    ``// Function to print duplicates``    ``void` `printRepeating(``int` `arr[], ``int` `size)``    ``{``        ``int` `i;``        ``System.out.println(``"The repeating elements are : "``);``        ` `        ``for` `(i = ``0``; i < size; i++) {``            ``int` `j = Math.abs(arr[i]);``            ``if` `(arr[j] >= ``0``)``                ``arr[j] = -arr[j];``            ``else``                ``System.out.print(j + ``" "``);``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``FindDuplicate duplicate = ``new` `FindDuplicate();``        ``int` `arr[] = { ``1``, ``2``, ``3``, ``1``, ``3``, ``6``, ``6` `};``        ``int` `arr_size = arr.length;` `        ``duplicate.printRepeating(arr, arr_size);``    ``}``}` `// This code has been contributed by Mayank Jaiswal`

## Python

 `# Python3 code to find``# duplicates in O(n) time` `# Function to print duplicates`  `def` `printRepeating(arr, size):` `    ``print``(``"The repeating elements are: "``)` `    ``for` `i ``in` `range``(``0``, size):` `        ``if` `arr[``abs``(arr[i])] >``=` `0``:``            ``arr[``abs``(arr[i])] ``=` `-``arr[``abs``(arr[i])]``        ``else``:``            ``print``(``abs``(arr[i]), end``=``" "``)`  `# Driver code``arr ``=` `[``1``, ``2``, ``3``, ``1``, ``3``, ``6``, ``6``]``arr_size ``=` `len``(arr)` `printRepeating(arr, arr_size)` `# This code is contributed by Shreyanshi Arun.`

## C#

 `// C# code to find``// duplicates in O(n) time``using` `System;` `class` `GFG {``    ``static` `void` `printRepeating(``int``[] arr, ``int` `size)``    ``{``        ``int` `i;` `        ``Console.Write(``"The repeating"` `+``                      ``" elements are : "``);` `        ``for` `(i = 0; i < size; i++) {``            ``int` `j = Math.Abs(arr[i]);``            ``if` `(arr[j] >= 0)``                ``arr[j] = -arr[j];``            ``else``                ``Console.Write(j + ``" "``);``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int``[] arr = { 1, 2, 3, 1, 3, 6, 6 };``        ``int` `arr_size = arr.Length;` `        ``printRepeating(arr, arr_size);``    ``}``}` `// This code is contributed by Sam007`

## PHP

 `= 0)``            ``\$arr``[``abs``(``\$arr``[``\$i``])] = -``\$arr``[``abs``(``\$arr``[``\$i``])];``        ``else``            ``echo` `abs``(``\$arr``[``\$i``]) . ``" "``;``    ``}``}` `// Driver Code``\$arr` `= ``array``(1, 2, 3, 1, 3, 6, 6);``\$arr_size` `= ``count``(``\$arr``);``printRepeating(``\$arr``, ``\$arr_size``);` `// This code is contributed by Sam007``?>`

## Javascript

 ``

Output:

```The repeating elements are:
1  3  6```

Complexity Analysis:

• Time Complexity: O(n), only one traversal is needed, so time complexity is O(n)
• Auxiliary Space: O(1), no extra space is required, so space complexity is constant.

Alternate Solution:

• Approach: The basic idea is to use a HashMap to solve the problem. But there is a catch, the numbers in the array are from 0 to n-1, and the input array has length n. So, the input array can be used as a HashMap. While Traversing the array, if an element ‘a’ is encountered then increase the value of a%n‘th element by n. The frequency can be retrieved by dividing the a % n’th element by n.
• Algorithm:
1. Traverse the given array from start to end.
2. For every element in the array increment the arr[i]%n‘th element by n.
3. Now traverse the array again and print all those indexes i for which arr[i]/n is greater than 1. Which guarantees that the number n has been added to that index
4. This approach works because all elements are in the range from 0 to n-1 and arr[i] would be greater than n only if a value “i” has appeared more than once.

Implementation:

## C++

 `// C++ code to find``// duplicates in O(n) time``#include ``using` `namespace` `std;` `int` `main()``{` `    ``int` `numRay[] = { 0, 4, 3, 2, 7, 8, 2, 3, 1 };``    ``int` `arr_size = ``sizeof``(numRay) / ``sizeof``(numRay);``  ` `  ` `    ``// count the frequency``    ``for` `(``int` `i = 0; i < arr_size; i++) {``        ``numRay[numRay[i] % arr_size]``            ``= numRay[numRay[i] % arr_size] + arr_size;``    ``}``    ``cout << ``"The repeating elements are : "` `<< endl;``    ``for` `(``int` `i = 0; i < arr_size; i++) {``        ``if` `(numRay[i] >= arr_size * 2) {``            ``cout << i << ``" "` `<< endl;``        ``}``    ``}``    ``return` `0;``}` `// This code is contributed by PrinciRaj1992`

## Java

 `// JAVA code to find``// duplicates in O(n) time` `class` `Leet442 {` `    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `numRay[] = { ``0``, ``4``, ``3``, ``2``, ``7``, ``8``, ``2``, ``3``, ``1` `};` `        ``for` `(``int` `i = ``0``; i < numRay.length; i++) {``            ``numRay[numRay[i] % numRay.length]``                ``= numRay[numRay[i] % numRay.length]``                  ``+ numRay.length;``        ``}``        ``System.out.println(``"The repeating elements are : "``);``        ``for` `(``int` `i = ``0``; i < numRay.length; i++) {``            ``if` `(numRay[i] >= numRay.length * ``2``) {``                ``System.out.println(i + ``" "``);``            ``}``        ``}``    ``}``}`

## Python

 `# Python3 code to find duplicates in O(n) time``numRay ``=` `[``0``, ``4``, ``3``, ``2``, ``7``, ``8``, ``2``, ``3``, ``1``]``arr_size ``=` `len``(numRay)``for` `i ``in` `range``(arr_size):` `    ``x ``=` `numRay[i] ``%` `arr_size``    ``numRay[x] ``=` `numRay[x] ``+` `arr_size` `print``(``"The repeating elements are : "``)``for` `i ``in` `range``(arr_size):``    ``if` `(numRay[i] >``=` `arr_size``*``2``):``        ``print``(i, ``" "``)` `# This code is contributed by 29AjayKumar`

## C#

 `// C# code to find``// duplicates in O(n) time``using` `System;``class` `Leet442``{``    ``public` `static` `void` `Main(String []args)``    ``{``        ``int` `[]numRay = { 0, 4, 3, 2, 7, 8, 2, 3, 1 };` `        ``for` `(``int` `i = 0; i < numRay.Length; i++)``        ``{``            ``numRay[numRay[i] % numRay.Length]``                ``= numRay[numRay[i] % numRay.Length]``                ``+ numRay.Length;``        ``}``        ``Console.WriteLine(``"The repeating elements are : "``);``        ``for` `(``int` `i = 0; i < numRay.Length; i++)``        ``{``            ``if` `(numRay[i] >= numRay.Length * 2)``            ``{``                ``Console.WriteLine(i + ``" "``);``            ``}``        ``}``    ``}``}` `// This code is contributed by shivanisinghss2110`

## Javascript

 ``

Output:

```The repeating elements are :
2
3```

Complexity Analysis:

• Time Complexity: O(n).
Only two traversals are needed. So the time complexity is O(n).
• Auxiliary Space: O(1).
No extra space is needed, so the space complexity is constant.

My Personal Notes arrow_drop_up