# 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.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Article Tags :

73

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