Find all duplicate numbers in array

Given an array of positive integers in range 0 to N-1, find all duplicate numbers in the array. The array is not sorted. For example:
A = [2,4,3,2,1,5,4] Duplicate numbers are 2,4 whereas in A = [4,1,3,2,1,1,5,5] duplicate numbers are 1,5.

Brute force solution would be to keep track of every number which is already visited. The basic idea behind the solution is to keep track that whether we have visited the number before or not. Which data structure is good for quick lookups like this? Of course a map or hash.
The time complexity of this solution is `O(n)` but it has an additional space complexity of `O(n)`.

To reduce space requirement, a bit array can be used, where ith index is set whenever we encounter number i in the given array. If the bit is set already, its a duplicate number. It takes `O(n)` extra space which is actually less than earlier `O(n)` as only bits are used. The time complexity remains `O(n)`

Find duplicate numbers in an array without additional space

Can we use the given array itself to keep track of the already visited numbers? How can we change a number in an array while also be able to get the original number back whenever needed? That is where reading the problem statement carefully comes. Since array contains only positive numbers, we can negate the number at the index equal to the number visited. If ever find a number at any index negative, that means we have seen that number earlier as well and hence should be a duplicate.

Idea is to make the number at ith index of array negative whenever we see number i in the array. If the number at ith index is already negative, it means we have already visited this number and it is duplicate. Limitation of this method is that it will not work for negative numbers.

Duplicate numbers implementation

```package AlgorithmsAndMe;

import java.util.HashSet;
import java.util.Set;

public class DuplicatesInArray {

public Set<Integer> getAllDuplicates(int[] a )
throws IllegalArgumentException {

Set<Integer> result = new HashSet<>();

if(a == null) return result;

for(int i=0; i<a.length; i++) {
//In case input is wrong
if(Math.abs(a[i]) >= a.length ){
throw new IllegalArgumentException();
}

if (a[Math.abs(a[i])] < 0) {
} else {
a[Math.abs(a[i])] = -a[Math.abs(a[i])];
}
}
return result;
}
}

```

Test cases

```package Test;

import AlgorithmsAndMe.DuplicatesInArray;
import java.util.Set;

public class DuplicatesInArrayTest {

DuplicatesInArray duplicatesInArray = new DuplicatesInArray();

@org.junit.Test
public void testDuplicatesInArray() {
int [] a = { 1,2,3,4,2,5,4,3,3};
Set<Integer> result = duplicatesInArray.getAllDuplicates(a);

result.forEach(s -> System.out.println(s));
}

@org.junit.Test
public void testDuplicatesInArrayWithNullArray() {
Set<Integer> result = duplicatesInArray.getAllDuplicates(null);

result.forEach(s -> System.out.println(s));
}

//This case should generate an exception as 3 is greater than the size.
@org.junit.Test
public void testDuplicatesInArrayWithNullArray() {
int [] a = { 1,2,3};
try{
Set<Integer> result = duplicatesInArray.getAllDuplicates(a);
} catch (IllegalArgumentException  e){
System.out.println("invalid input provided");
}
}
}

```

The complexity of the algorithm to find duplicate elements in an array is `O(n)`.

Repeated number in an array

In last post : Find missing number in array, we learned how to find a missing number in array of integers with values in a given range. Today, we will learn how find a repeated number in array of integers from 1 to N. Note that here also, numbers are not sorted but are confined to a range. So, if size of array is N, then range of numbers is from 1 to N-1 as one number is repeated. Examples :

```A = [1,2,3,3,4,5]. Repeated number is 3
Size of array : 6 Range : 1 to 5
```

Repeated number : Algorithm

As we have learned while solving the missing number problem earlier, XOR principle can be applied here too. Why? Because in this case repeated number will be XORed with itself three times. Properties of XOR to understand the method and how we use them.

```A XOR A = 0
0 XOR A = A
```

Now, when a number XORed with itself, the result is zero, and when zero is XORed with a number, the result is the number itself. Extending this, if we XORed the same number thrice or without losing generality, an odd number of times, the result will be the number itself.

Using an odd number of times XOR principle, algorithm to find repeating number in an array.

1. XOR all actual numbers in the array. Call it aXOR.
2. XOR all numbers in range 1 to N-1. Call it eXOR
3. XOR aXOR with eXOR. Result will be repeated number.

This is because all numbers except the repeated number will be XORed even number of times, and cancel each other. The repeated number will be XORed thrice, the final result will be the repeated number. Let’s take above example and see if it works

```A = [1,2,2,3,4]

aXOR = 001 XOR 010 = 011 XOR 010 = 001 XOR 011 = 010 XOR 100 = 110
eXOR = 001 XOR 010 = 011 XOR 011 = 000 XOR 100 = 100

ActualXOR XOR expectedXOR = 110 XOR 100 = 010
```

Repeated number in array implementation

```public int repeatedNumber(int[] nums) {

int n =  nums.length;

int nXOR = 0;
for(int i=0; i<=n; i++){
nXOR ^= i;
}

int aXOR = 0;
for(int i=0; i<n; i++){
aXOR ^= nums[i];
}

return aXOR ^ nXOR;
}
```

The time complexity of the XOR method to find a repeated number in an array is `O(n)`.

Please share your thoughts through comments, if you see something is missing or wrong or not explained properly.