Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Find duplicates in a given array when elements are not limited to a range

  • Difficulty Level : Easy
  • Last Updated : 22 Jun, 2021

Given an array of n integers. The task is to print the duplicates in the given array. If there are no duplicates then print -1. 

Examples: 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: {2, 10,10, 100, 2, 10, 11,2,11,2}
Output: 2 10 11

Input: {5, 40, 1, 40, 100000, 1, 5, 1}
Output: 5 40 1

Note: The duplicate elements can be printed in any order.



Simple Approach: The idea is to use nested loop and for each element check if the element is present in the array more than once or not. If present, then store it in a Hash-map. Otherwise, continue checking other elements.

Below is the implementation of the above approach:

C++




// C++ implementation of the
// above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the Duplicates,
// if duplicate occurs 2 times or
// more than 2 times in array so,
// it will print duplicate value
// only once at output
void findDuplicates(int arr[], int len)
{
     
    // Initialize ifPresent as false
    bool ifPresent = false;
 
    // ArrayList to store the output
    vector<int> al;
 
    for(int i = 0; i < len - 1; i++)
    {
        for(int j = i + 1; j < len; j++)
        {
            if (arr[i] == arr[j])
            {
                 
                // Checking if element is
                // present in the ArrayList
                // or not if present then break
                auto it = std::find(al.begin(),
                                    al.end(), arr[i]);
                                     
                if (it != al.end())
                {
                    break;
                }
 
                // If element is not present in the
                // ArrayList then add it to ArrayList
                // and make ifPresent at true
                else
                {
                    al.push_back(arr[i]);
                    ifPresent = true;
                }
            }
        }
    }
 
    // If duplicates is present
    // then print ArrayList
    if (ifPresent == true)
    {
        cout << "[" << al[0] << ", ";
        for(int i = 1; i < al.size() - 1; i++)
        {
            cout << al[i] << ", ";
        }
         
        cout << al[al.size() - 1] << "]";
    }
    else
    {
        cout << "No duplicates present in arrays";
    }
}
 
// Driver code
int main()
{
    int arr[] = { 12, 11, 40, 12,
                  5, 6, 5, 12, 11 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    findDuplicates(arr, n);
 
    return 0;
}
 
// This code is contributed by divyeshrabadiya07
Java



// Java implementation of the
// above approach
 
import java.util.ArrayList;
 
public class GFG {
 
    // Function to find the Duplicates,
    // if duplicate occurs 2 times or
    // more than 2 times in
    // array so, it will print duplicate
    // value only once at output
    static void findDuplicates(
      int arr[], int len)
    {
 
        // initialize ifPresent as false
        boolean ifPresent = false;
 
        // ArrayList to store the output
        ArrayList<Integer> al = new ArrayList<Integer>();
 
        for (int i = 0; i < len - 1; i++) {
            for (int j = i + 1; j < len; j++) {
                if (arr[i] == arr[j]) {
                    // checking if element is
                    // present in the ArrayList
                    // or not if present then break
                    if (al.contains(arr[i])) {
                        break;
                    }
 
                    // if element is not present in the
                    // ArrayList then add it to ArrayList
                    // and make ifPresent at true
                    else {
                        al.add(arr[i]);
                        ifPresent = true;
                    }
                }
            }
        }
 
        // if duplicates is present
        // then print ArrayList
        if (ifPresent == true) {
 
            System.out.print(al + " ");
        }
        else {
            System.out.print(
                "No duplicates present in arrays");
        }
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        int arr[] = { 12, 11, 40, 12, 5, 6, 5, 12, 11 };
        int n = arr.length;
 
        findDuplicates(arr, n);
    }
}
Python3



# Python3 implementation of the
# above approach
 
# Function to find the Duplicates,
# if duplicate occurs 2 times or
# more than 2 times in array so,
# it will print duplicate value
# only once at output
def findDuplicates(arr, Len):
     
    # Initialize ifPresent as false
    ifPresent = False
 
    # ArrayList to store the output
    a1 = []
    for i in range(Len - 1):
        for j in range(i + 1, Len):
 
            # Checking if element is
            # present in the ArrayList
            # or not if present then break
            if (arr[i] == arr[j]):
                if arr[i] in a1:
                    break
                 
                # If element is not present in the
                # ArrayList then add it to ArrayList
                # and make ifPresent at true
                else:
                    a1.append(arr[i])
                    ifPresent = True
 
    # If duplicates is present
    # then print ArrayList
    if (ifPresent):
        print(a1, end = " ")
    else:
        print("No duplicates present in arrays")
 
# Driver Code
arr = [ 12, 11, 40, 12, 5, 6, 5, 12, 11 ]
n = len(arr)
 
findDuplicates(arr, n)
 
# This code is contributed by rag2127
C#



// C# implementation of the
// above approach
using System;
using System.Collections.Generic;
 
class GFG{
     
// Function to find the Duplicates,
// if duplicate occurs 2 times or
// more than 2 times in array so,
// it will print duplicate value
// only once at output
static void findDuplicates(int[] arr, int len)
{
     
    // Initialize ifPresent as false
    bool ifPresent = false;
 
    // ArrayList to store the output
    List<int> al = new List<int>();
 
    for(int i = 0; i < len - 1; i++)
    {
        for(int j = i + 1; j < len; j++)
        {
            if (arr[i] == arr[j])
            {
                 
                // Checking if element is
                // present in the ArrayList
                // or not if present then break
                if (al.Contains(arr[i]))
                {
                    break;
                }
 
                // If element is not present in the
                // ArrayList then add it to ArrayList
                // and make ifPresent at true
                else
                {
                    al.Add(arr[i]);
                    ifPresent = true;
                }
            }
        }
    }
 
    // If duplicates is present
    // then print ArrayList
    if (ifPresent == true)
    {
        Console.Write("[" + al[0] + ", ");
        for(int i = 1; i < al.Count - 1; i++)
        {
            Console.Write(al[i] + ", ");
        }
        Console.Write(al[al.Count - 1] + "]");
    }
    else
    {
        Console.Write("No duplicates present in arrays");
    }
}
 
// Driver code   
static void Main()
{
    int[] arr = { 12, 11, 40, 12,
                  5, 6, 5, 12, 11 };
    int n = arr.Length;
 
    findDuplicates(arr, n);
}
}
 
// This code is contributed by divyesh072019
Javascript



<script>
 
// JavaScript implementation of the
// above approach
 
// Function to find the Duplicates,
// if duplicate occurs 2 times or
// more than 2 times in
// array so, it will print duplicate
// value only once at output
function findDuplicates(arr, len) {
 
    // initialize ifPresent as false
    let ifPresent = false;
 
    // ArrayList to store the output
    let al = new Array();
 
    for (let i = 0; i < len - 1; i++) {
        for (let j = i + 1; j < len; j++) {
            if (arr[i] == arr[j]) {
                // checking if element is
                // present in the ArrayList
                // or not if present then break
                if (al.includes(arr[i])) {
                    break;
                }
 
                // if element is not present in the
                // ArrayList then add it to ArrayList
                // and make ifPresent at true
                else {
                    al.push(arr[i]);
                    ifPresent = true;
                }
            }
        }
    }
 
    // if duplicates is present
    // then print ArrayList
    if (ifPresent == true) {
 
        document.write(`[${al}]`);
    }
    else {
        document.write("No duplicates present in arrays");
    }
}
 
// Driver Code
 
let arr = [12, 11, 40, 12, 5, 6, 5, 12, 11];
let n = arr.length;
 
findDuplicates(arr, n);
 
</script>
Output
[12, 11, 5]
Time Complexity: O(N2) 
Auxiliary Space: O(N)
Efficient Approach: Use unordered_map for hashing. Count frequency of occurrence of each element and the elements with frequency more than 1 is printed. unordered_map is used as range of integers is not known. For Python, Use Dictionary to store number as key and it’s frequency as value. Dictionary can be used as range of integers is not known.
Below is the implementation of the above approach:
C++



// C++ program to find
// duplicates in the given array
#include <bits/stdc++.h>
using namespace std;
 
// function to find and print duplicates
void printDuplicates(int arr[], int n)
{
    // unordered_map to store frequencies
    unordered_map<int, int> freq;
    for (int i=0; i<n; i++)
        freq[arr[i]]++;
 
    bool dup = false;
    unordered_map<int, int>:: iterator itr;
    for (itr=freq.begin(); itr!=freq.end(); itr++)
    {
        // if frequency is more than 1
        // print the element
        if (itr->second > 1)
        {
            cout << itr->first << " ";
            dup = true;
        }
    }
 
    // no duplicates present
    if (dup == false)
        cout << "-1";
}
 
// Driver program to test above
int main()
{
    int arr[] = {12, 11, 40, 12, 5, 6, 5, 12, 11};
    int n = sizeof(arr) / sizeof(arr[0]);
    printDuplicates(arr, n);
    return 0;
}
Java



// Java program to find
// duplicates in the given array
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
 
public class FindDuplicatedInArray
{
    // Driver program
    public static void main(String[] args)
    {
        int arr[] = {12, 11, 40, 12, 5, 6, 5, 12, 11};
        int n = arr.length;
        printDuplicates(arr, n);
    }
    // function to find and print duplicates
    private static void printDuplicates(int[] arr, int n)
    {
        Map<Integer,Integer> map = new HashMap<>();
        int count = 0;
        boolean dup = false;
        for(int i = 0; i < n; i++){
            if(map.containsKey(arr[i])){
                count = map.get(arr[i]);
                map.put(arr[i], count + 1);
            }
            else{
                map.put(arr[i], 1);
            }
        }
         
        for(Entry<Integer,Integer> entry : map.entrySet())
        {
            // if frequency is more than 1
            // print the element
            if(entry.getValue() > 1){
                System.out.print(entry.getKey()+ " ");
                dup = true;
            }
        }
        // no duplicates present
        if(!dup){
            System.out.println("-1");
        }
    }
}
Python3



# Python3 program to find duplicates
# using dictionary approach.
def printDuplicates(arr):
    dict = {}
 
    for ele in arr:
        try:
            dict[ele] += 1
        except:
            dict[ele] = 1
             
    for item in dict:
         
         # if frequency is more than 1
         # print the element
        if(dict[item] > 1):
            print(item, end=" ")
 
    print("\n")
 
# Driver Code
if __name__ == "__main__":
    list = [12, 11, 40, 12,
            5, 6, 5, 12, 11]
    printDuplicates(list)
 
# This code is contributed
# by Sushil Bhile
C#



// C# program to find
// duplicates in the given array
using System;
using System.Collections.Generic;
 
class GFG
{
    // function to find and print duplicates
    static void printDuplicates(int[] arr, int n)
    {
        Dictionary<int,
                   int> map = new Dictionary<int,
                                             int>();
        int count = 0;
        bool dup = false;
        for (int i = 0; i < n; i++)
        {
            if (map.ContainsKey(arr[i]))
            {
                count = map[arr[i]];
                map[arr[i]]++;
            }
            else
                map.Add(arr[i], 1);
        }
 
        foreach (KeyValuePair<int,
                              int> entry in map)
        {
            // if frequency is more than 1
            // print the element
            if (entry.Value > 1)
                Console.Write(entry.Key + " ");
            dup = true;
        }
 
        // no duplicates present
        if (!dup)
            Console.WriteLine("-1");
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        int[] arr = { 12, 11, 40, 12,
                     5, 6, 5, 12, 11 };
        int n = arr.Length;
        printDuplicates(arr, n);
    }
}
 
// This code is contributed by
// sanjeev2552
Javascript



<script>
 
// JavaScript program to find
// duplicates in the given array
 
// Function to find and print duplicates
function printDuplicates(arr, n)
{
     
    // unordered_map to store frequencies
    var freq = new Map();
    for(let i = 0; i < n; i++)
    {
        if (freq.has(arr[i]))
        {
            freq.set(arr[i], freq.get(arr[i]) + 1);
        }
        else
        {
            freq.set(arr[i], 1);
        }
    }
     
    var dup = false;
    for(let [key, value] of freq)
    {
         
        // If frequency is more than 1
        // print the element
        if (value > 1)
        {
            document.write(key + " ");
            dup = true;
        }
    }
     
    // No duplicates present
    if (dup == false)
        document.write("-1");
}
 
// Driver code
var arr = [ 12, 11, 40, 12,
            5, 6, 5, 12, 11 ];
var n = arr.length;
 
printDuplicates(arr, n);
 
// This code is contributed by lokeshpotta20
 
</script>
Output
5 12 11
Time Complexity: O(N)
Auxiliary Space: O(N)
Related Post : 
Print All Distinct Elements of a given integer array 
Find duplicates in O(n) time and O(1) extra space | Set 1 
Duplicates in an array in O(n) and by using O(1) extra space | Set-2 
Print all the duplicates in the input string
This article is contributed by Ayush Jauhari. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



My Personal Notes
arrow_drop_up
Next

Find duplicates in O(n) time and O(1) extra space | Set 1
Recommended Articles
Page :
Find even occurring elements in an array of limited range
25, Jun 16
Smallest element repeated exactly ‘k’ times (not limited to small range)
30, Aug 17
Find the missing number in a sorted array of limited range
29, Jul 17
Find frequency of each element in a limited range array in less than O(n) time
29, Jun 16
Find if array can be sorted by swaps limited to multiples of k
27, Apr 20
Minimum partitions of maximum size 2 and sum limited by given value
04, Sep 18
Find duplicates in constant array with elements 0 to N-1 in O(1) space
30, Mar 18
Find the frequencies of all duplicates elements in the array
25, Mar 20
Find a Fixed Point (Value equal to index) in a given array | Duplicates Allowed
26, Jan 18
Find Duplicates of array using bit array
18, Apr 17
Count numbers from a given range that are not divisible by any of the array elements
07, Jan 21
Queries to find the maximum and minimum array elements excluding elements from a given range
03, Feb 21
Find all numbers in range [1, N] that are not present in given Array
25, Aug 21
Find duplicates under given constraints
01, Mar 17
Find Equal (or Middle) Point in a sorted array with duplicates
02, Dec 16
Find duplicates in an Array with values 1 to N using counting sort
23, Jun 20
Find a Fixed Point in an array with duplicates allowed
06, Jun 17
Range Queries to count elements lying in a given Range : MO's Algorithm
07, May 20
Queries for elements having values within the range A to B in the given index range using Segment Tree
27, Apr 20
Queries to increment array elements in a given range by a given value for a given number of times
16, Oct 20
Sum of elements in given range from Array formed by infinitely concatenating given array
09, Jul 21
Find duplicates in O(n) time and O(1) extra space | Set 1
04, Jan 11
Rearrange given Array such that each elements is not equal to mean of adjacent elements
17, Aug 21
Find the XOR of the elements in the given range [L, R] with the value K for a given set of queries
08, May 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!