Find Duplicate in Array
You are given an array of integers 'ARR' containing N elements. Each integer is in the range [1, N-1], with exactly one element repeated in the array.

Your task is to find the duplicate element.

Note :

All the integers in the array appear only once except for precisely one integer which appears two or more times.

Input format:

The first line of input contains an integer ‘T’ denoting the number of test cases. Then the T test cases follow. The first line of each test case contains an integer ‘N’, the number of elements in the array. The second line of each test case contains ‘N’ space-separated integers representing the elements of the array.

Output format:

For each test case, the duplicate element of the given array is printed. The output of each test case is printed in a separate line.

Note :

You are not supposed to print anything; It has already been taken care of. Just implement the given function.

Constraints :

1

Question

Find Duplicate in Array

You are given an array of integers 'ARR' containing N elements. Each integer is in the range [1, N-1], with exactly one element repeated in the array.

Your task is to find the duplicate element.

Note :

All the integers in the array appear only once except for precisely one integer which appears two or more times.

Input format:

The first line of input contains an integer ‘T’ denoting the number of test cases. Then the T test cases follow.

The first line of each test case contains an integer ‘N’, the number of elements in the array. 

The second line of each test case contains ‘N’ space-separated integers representing the elements of the array.

Output format:

For each test case, the duplicate element of the given array is printed.

The output of each test case is printed in a separate line.

Note :

You are not supposed to print anything; It has already been taken care of. Just implement the given function.

Constraints :

1 <= T <= 5
1 <= N <= 10^5
1 <= ARR[i] <= N - 1

Time Limit: 1 sec

Accepted Answer

Concept of indexing can be used to solve this question.
Traverse the array. For every element at index i,visit a[i]. If a[i] is positive, then change it to negative. If a[i] is negative, it means the element has already been visited and thus it is repeated. Print that element.
Pseudocode :
findRepeating(arr[], n)
{
missingElement = 0

for (i = 0; i < n; i++){
element = arr[abs(arr[i])]

if(element < 0){
missingElement = arr[i]
break
}

arr[abs(arr[i])] = -arr[abs(arr[i])]
}
return abs(missingElement)
}

Accepted Answer

Using Sort

First, we sort the array. Now, the rest of the algorithm becomes fairly simple. We just compare each element to its previous element. As we know there is exactly one repeated element, hence we can simply just return the element, which is equal to its previous element as soon as we find it.

Space Complexity: O(1)Explanation:

O(1) or O(N),

We can sort the array either in place or by taking another array if modifying the given array is not permitted. Here we suppose that modifying the array is possible, hence using constant space makes space complexity = O(1).

Time Complexity: O(nlogn)Explanation:

O(N * log(N)), where N is the length of the array.

The sorting of elements costs O(N * log(N)) time, which dominates the subsequent linear scan.

C++ (g++ 5.4)

/*



	Time complexity: O(N * log(N)) 

	Space complexity: O(1)

	

	Where N is the length of the array.



*/



#include



int findDuplicate(vector &arr, int n)

{

    

    // Sort the elements of the array.

    sort(arr.begin(), arr.end());



    // Traverse through the array to check if two consecutive elements are equal.

    for(int i = 0; i < n - 1; i++)

    {



        // Duplicate element found.

        if(arr[i] == arr[i+1]) 

        {



            // Return the duplicate element.

            return arr[i];

        }

    }

    return -1;

}

Python (3.5)

'''

	Time complexity: O(N * log(N)) 
	Space complexity: O(1)
	
	Where N is the length of the array.

'''

def findDuplicate(arr, n):
    
    # Sort the elements of the array.
    arr.sort()
    
    # Traverse through the loop to check if two consecutive elements are equal.
    for i in range(n - 1):
        # Duplicate element found.
        if arr[i] == arr[i + 1]:
           
           # Return the duplicate element.
           return arr[i]
           
           
    return -1

Java (SE 1.8)

/*



	Time complexity: O(N * log(N)) 

	Space complexity: O(1)

	

	Where N is the length of the array.



*/



import java.util.ArrayList;

import java.util.Collections;



public class Solution{



    public static int findDuplicate(ArrayList arr, int n){



        // Sort the elements of the array.

        Collections.sort(arr);



        // Traverse through the loop to check if two consecutive elements are equal.

        for(int i = 0; i < n - 1; i++){



            // Duplicate element found.

            if(arr.get(i) == arr.get(i+1)) {



                // Return the duplicate element.

                return arr.get(i);

            }

        }

        return -1;

    }

}

Accepted Answer

Binary Search

We perform binary search on the array [1,N], then COUNT the number of elements that are less than or equal to MID of [1,N]. If the duplicate is on the left side of the middle element, then the COUNT should be more than MID, else it is on the right side. Narrow down the search space each time until you find the repeating number then return it.

Example: Input: 2 4 1 5 3 6 8 7 4

Explanation:

LOW = 1, HIGH = 9, MID = 5

COUNT elements smaller or equal to MID: count = 6

COUNT > MID , hence the repeated element is less than 5 ->

HIGH = MID = 5, hence new MID = 3, now count elements smaller or equal to mid: COUNT = 3

COUNT <= MID, hence the repeated element is greater than 3 ->

LOW = MID + 1 = 4, hence new MID = 4, now count elements smaller or equal to mid: COUNT = 5

COUNT > MID , hence the repeated element is less than or equal to 4 ->

HIGH = MID = 4, hence new MID = old MID = 4, hence repeated element = 4.

Output:

4

Space Complexity: O(1)Explanation:

O(1), Constant space is required.

Time Complexity: O(nlogn)Explanation:

O(N * log(N)), where N is the length of the array.

Search space decreases each time by half hence making the time complexity = O(N * log(N)).

Python (3.5)

'''

	Time complexity: O(N * log(N)) 
	Space complexity: O(1)
	
	Where N is the length of the array.

'''

def findDuplicate(arr, n):
    # Initialise low and high pointers.
    low = 1
    high = n
    
    # Loop until low < high.
    while low < high:
        
        # Find mid element.
        mid = low + (high - low) // 2
        
        # Count variable to count number of elements less than mid.
        count = 0
        
        # Count the number of elements smaller / equal to mid element.
        for i in range(n):
            if arr[i] <= mid:
                count += 1
                
        # Duplicate element is on left side of mid hence high = mid.
        if count > mid:
            high = mid
            
        # Duplicate element is on the right side of mid hence low = mid + 1.
        else:
            low = mid + 1
            
    
    return low

C++ (g++ 5.4)

/*



	Time complexity: O(N * log(N)) 

	Space complexity: O(1)

	

	Where N is the length of the array.



*/



int findDuplicate(vector &arr, int n)

{



    // Initialise low and high pointers.

    int low = 1, high = n;



    // Find mid.

    while(low < high)

    {



        // Initialise mid element.

        int mid = low + (high - low) / 2;



        // Initialise count variable to count number of elements less than mid.

        int count = 0;



        // Count the number of elements smaller / equal to mid element.

        for(int i = 0; i < n; i++)

        {

            if(arr[i] <= mid)

            {

                count++;

            }

        }



        // Duplicate element is on left side of mid hence high = mid.

        if(count > mid)

        {

            high = mid;

        }



        // Duplicate element is on the right side of mid hence low = mid + 1.

        else

        { 

           low = mid + 1;

        }

    }



    return low;

}

Java (SE 1.8)

/*



	Time complexity: O(N * log(N)) 

	Space complexity: O(1)

	

	Where N is the length of the array.



*/



import java.util.ArrayList;



public class Solution{



    public static int findDuplicate(ArrayList arr, int n){



        // Initialise low and high pointers.

        int low = 1, high = n;



        // Loop until low < high.

        while(low < high)

        {



            // Find mid element.

            int mid = low + (high - low) / 2;



            // Count variable to count number of elements less than mid.s

            int count = 0;



            // Count the number of elements smaller / equal to mid element.

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

                if(arr.get(i) <= mid){

                    count++;

                }

            }



            // Duplicate element is on left side of mid hence high = mid.

            if(count > mid){

                high = mid;

            }



            // Duplicate element is on the right side of mid hence low = mid + 1.

            else{ 

            	low = mid + 1;

            }

        }



        return low;

    }



}

Accepted Answer

Using Set

We need to insert elements into a data structure and look them up in constant time, so as to improve the complexity of sorting approach. A set can be used to satisfy these conditions. So, we iterate over the array and insert each element into a set. Before inserting we check whether the element is already present in the set or not. If it is found, we get the repeated element and hence return it.

Space Complexity: O(n)Explanation:

O(N), where N is the length of the array.

Extra space for the set makes the space complexity is O(N).

Time Complexity: O(n)Explanation:

O(N), where N is the length of the array.

The insertion and lookup in the ‘set’ takes constant time, hence the complexity will only be due to the linear traversal making complexity = O(N).

Python (3.5)

'''

	Time complexity: O(N) 
	Space complexity: O(N)
	
	Where N is the length of the array.

'''

def findDuplicate(arr, n):
    
    # Create an unordered set to store each element.
    uset = set()
    
    # For each value of array perform.
    for i in range(n):
        
        # Check if element alrady present.
        if arr[i] in uset:
            
            # If present return repeated element.
            return arr[i]
        
        else:
            
            uset.add(arr[i])
            
            
    return -1

C++ (g++ 5.4)

/*



	Time complexity: O(N) 

	Space complexity: O(N)

	

	Where N is the length of the array.



*/



int findDuplicate(vector &arr, int n)

{



    // Create an unordered set to store each element.

    unordered_set uset;



    // For each value of array perform.

    for (int i : arr) 

    {



        // Check if current element is already present.

        if (uset.find(i) != uset.end()) 

        {



            // If present return this repeated element.

            return i;

        }

        else

        {



            // If element not found, insert it into the set.

            uset.insert(i);

        }

    }



    return -1;

}

Java (SE 1.8)

/*



	Time complexity: O(N) 

	Space complexity: O(N)

	

	Where N is the length of the array.



*/



import java.util.ArrayList;

import java.util.*;  



public class Solution{



    public static int findDuplicate(ArrayList arr, int n){



        // Create an unordered set to store each element.

        Set uset = new HashSet(); 



        // For each value of array perform.

        for (int i = 0; i < n ; i++) 

        {



            // Check if element alrady present.

            if (uset.contains(arr.get(i))) 

            {



                // If present return repeated element.

                return arr.get(i);

            }

            else

            {



                // If not found in uset, insert into it.

                uset.add(arr.get(i));

            }

        }



        return -1;

    }

}

Accepted Answer

Modifying Array IN-PLACE

For this approach we use the array indices to store the visited state of each number. We know that only the duplicate element would be visited more than once. For each number we go to its index position and multiply it with ’-1’, thus making it negative. In case of duplicate, it will visit twice and hence will become positive, which will be returned.

Example: Input: 2 4 1 5 3 6 8 7 4

Explanation:

Traverse from start and multiply each element with ‘-1’ and checking if after multiplication it becomes positive then return it.

2 4 1 5 3 6 8 7 4

-2 -4 -1 -5 -3 -6 -8 -7 4

4 is positive hence return 4

Output:

4

Space Complexity: O(1)Explanation:

O(1), Constant space is required.

Time Complexity: O(n)Explanation:

O(N), where N is the length of the array.

We need to traverse the array only once hence, in the worst case the complexity will be O(N).

C++ (g++ 5.4)

/*



	Time complexity: O(N) 

	Space complexity: O(1)

	

	Where N is the length of the array.



*/



int findDuplicate(vector &arr, int n)

{



    // Traverse through the array.

    for(int i = 0; i < n; i++) 

    {



            // Use array indices to store visited state of each element.

            int index = abs(arr[i]) - 1;

            

            // Mark as visited by multiplying with '-1'.

            arr[index] *= -1;

            

            // In case of duplicate, this will become +ve.

            if(arr[index] > 0)

            {

                

                // Return duplicate element.

                return abs(arr[i]);

            }   

    } 

    

    return -1;

}

Python (3.5)

'''

	Time complexity: O(N) 
	Space complexity: O(1)
	
	Where N is the length of the array.

'''

def findDuplicate(arr, n):
    
    # For each value of array perform.
    for i in range(n):
        
        # Use array indices to store visited state of each element.
        index = abs(arr[i]) - 1
        
        # Mark as visited by multiplying with '-1'.
        arr[index] *= -1
        
        # In case of duplicate, this will become +ve.
        if arr[index] > 0:
            
            # Return duplicate element.
            return abs(arr[i])
            
            
    return -1

Java (SE 1.8)

/*



	Time complexity: O(N) 

	Space complexity: O(1)

	

	Where N is the length of the array.



*/



import java.util.ArrayList;



public class Solution{



    public static int findDuplicate(ArrayList arr, int n){



        // Traverse through the array.

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



            // Use array indices to store visited state of each element.

            int index = Math.abs(arr.get(i)) - 1;

            

            // Mark as visited by multiplying with '-1'.

            arr.set(index, arr.get(index) * -1);

            

            // In case of duplicate, this will become +ve.

            if(arr.get(index) > 0){

                

                // Return duplicate element.

                return Math.abs(arr.get(i));

            }   

        } 

        

        return -1;

    }

}

Accepted Answer

Floyd’s Tortoise and Hare Approach

For this approach, we divide the whole process into two phases and use two pointers named tortoise and hare..

Phase 1(Find the intersection point): The hare would be twice as fast as the tortoise. Hence, HARE = ARR[ARR[HARE]] and TORTOISE = ARR[TORTOISE]. Since the tortoise is slow, the hare would catch it at some point, this point will be our intersection point. Note that the intersection point may not be equal to the starting point of the loop.

Example: ARR = 2 4 1 5 3 6 8 7 4

Hare: 2 1 3 8 4 5 6 7

Tortoise: 2 4 1 5 3 6 8 7

In the above array, we can see that the intersection point of hare and tortoise will be 7 but the starting point of the loop is 4.

After finding the intersection point, we start with the second phase:

Phase 2:

Now, we reduce the speed of the hare and make it equal to the speed of the tortoise, meaning now HARE = ARR[HARE] and TORTOISE = ARR[TORTOISE]. The tortoise starts from the start of the array, while the hare starts from the intersection point found in the first phase. Now, the point where the hare and the tortoise intersect will be the starting point of the loop which is the repeated element and hence returned.

Space Complexity: O(1)Explanation:

O(1), Constant space is required.

Time Complexity: O(n)Explanation:

O(N), where N is the length of the array.

The time complexity of this algorithm is linear, hence O(N).

Java (SE 1.8)

/*



	Time complexity: O(N) 

	Space complexity: O(1)

	

	Where N is the length of the array.



*/



import java.util.ArrayList;



public class Solution{



    public static int findDuplicate(ArrayList arr, int n){



        // Initialise tortoise and hare pointers.

        int tortoise = arr.get(0);

        int hare = arr.get(0);



        do{



            // Hare pointer moves twice as fast as tortoise.

            tortoise = arr.get(tortoise);

            hare = arr.get(arr.get(hare));

        } 

        

        // Find the intersection point of the two runners.

        while (tortoise != hare);



        // To find the entrance to the cycle tortoise begins from start of array while hare begins from intersection point.

        tortoise = arr.get(0);



        while (tortoise != hare) {

        

        // This time both runners move with same speed.

        tortoise = arr.get(tortoise);

        hare = arr.get(hare);

        }



        // Return the entrance to the cycle, which will be the repeated element.

        return hare;



    }

}

C++ (g++ 5.4)

/*



	Time complexity: O(N) 

	Space complexity: O(1)

	

	Where N is the length of the array.



*/



int findDuplicate(vector &arr, int n)

{

    

    // Initialise tortoise and hare pointers.

    int tortoise = arr[0];

    int hare = arr[0];



    do 

    {



        // Hare pointer moves twice as fast as tortoise.

        tortoise = arr[tortoise];

        hare = arr[arr[hare]];

    } 

    

    // Find the intersection point of the two runners.

    while (tortoise != hare);



    // To find the entrance to the cycle tortoise begins from start of array while hare begins from intersection point.

    tortoise = arr[0];

    while (tortoise != hare) 

    {

      

      // This time both runners move with same speed.

      tortoise = arr[tortoise];

      hare = arr[hare];

    }



    // Return the entrance to the cycle, which will be the repeated element.

    return hare;

}

Python (3.5)

'''

	Time complexity: O(N) 
	Space complexity: O(1)
	
	Where N is the length of the array.

'''

def findDuplicate(arr, n):
    
    # Initialise tortoise and hare pointers.
    tortoise = arr[0]
    hare = arr[0]
    
    tortoise = arr[tortoise]
    hare = arr[arr[hare]]
    
    # Find the intersection point of the two runners.
    while tortoise != hare:
        # Hare pointer moves twice as fast as tortoise.
        tortoise = arr[tortoise]
        hare = arr[arr[hare]]
    
    # To find the entrance to the cycle tortoise begins from start of array while hare begins from intersection point.
    tortoise = arr[0]
    while tortoise != hare:
        # This time both runners move with same speed.
        tortoise = arr[tortoise]
        hare = arr[hare]
        
    # Return the entrance to the cycle, which will be the repeated element.
    return hare

You are given an array of integers 'ARR' containing N elements. Each integer is in the range [1, N-1], with exactly one element repeated in the array.

Your task is to find the duplicate element.

Note :

Input format:

Output format:

Note :

Constraints :

Top Housing.com Software Engineer interview questions & answers

Popular interview questions of Software Engineer