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

Given an array of n elements which 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:

```Input : n = 7 and array[] = {1, 2, 3, 1, 3, 6, 6}
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.
```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

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.
• 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])); ` `  ``} ` `} ` ` `  `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++) ` `        ``{ ` `            ``if` `(arr[ Math.abs(arr[i])] >= ``0``) ` `                ``arr[ Math.abs(arr[i])] = -arr[ Math.abs(arr[i])]; ` `            ``else` `                ``System.out.print(Math.abs(arr[i]) + ``" "``); ` `        ``}          ` `    ``}  ` ` `  `    ``// Driver program  ` `    ``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 `

## Python3

 `# 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++) ` `        ``{ ` `            ``if` `(arr[ Math.Abs(arr[i])] >= 0) ` `                ``arr[ Math.Abs(arr[i])] = ` `                    ``-arr[ Math.Abs(arr[i])]; ` `            ``else` `                ``Console.Write(Math.Abs(arr[i]) + ``" "``); ` `        ``}          ` `    ``}  ` ` `  `    ``// Driver program  ` `    ``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 ` `?> `

• Output:

```The repeating elements are:
1  3  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.
• 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.

There is a problem in the above approach.
It prints the repeated number more than once. For example: {1, 6, 3, 1, 3, 6, 6} it will give output as : 1 3 6 6. In below set, another approach is discussed that prints repeating elements only once.

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);  ` `    ``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

 `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): ` `  `  `    ``numRay[numRay[i] ``%` `arr_size] ``=` `numRay[numRay[i] ``%` `arr_size] ``+``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 `

• Output:
```The repeating elements are :
2
3```
• Complexity Anlaysis:
• 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.
• Duplicates in an array in O(n) and by using O(1) extra space | Set-2

Please write comments if you find the above codes/algorithms incorrect, or find better ways to solve the same problem.

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up

Article Tags :

39

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.