 Open in App
Not now

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

• Difficulty Level : Easy
• Last Updated : 20 Mar, 2023

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:

```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 ` `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 << ``", "``;` `        ``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);`   `    ``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 al = ``new` `ArrayList();`   `        ``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 + ``", "``);` `        ``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

 ``

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

 ``

Output

`5 12 11`

Time Complexity: O(N)
Auxiliary Space: O(N)

Another Efficient Approach(Space optimization):

• First we will sort the array for binary search function.
• we will find index at which arr[i] occur first time lower_bound
• Then , we will find index at which arr[i] occur last time upper_bound
• Then check if diff=(last_index-first_index+1)>1
• If diff >1 means it occurs more than once and print

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above approach`   `#include ` `using` `namespace` `std;`   `//Function to Print elements that occurs in arr more than 1` `void` `printDuplicates(``int` `arr[], ``int` `n)` `{   ` `    ``sort(arr,arr+n);``//sort array for binary search` `     `  `    ``cout<<``"["``;` `    ``for``(``int` `i = 0 ; i < n ;i++)` `    ``{ ` `      ``//index of first and last occ of arr[i];` `      ``int` `first_index = lower_bound(arr,arr+n,arr[i])- arr;` `      ``int` `last_index = upper_bound(arr,arr+n,arr[i])- arr-1;` `      `  `      ``int` `occur_time = last_index-first_index+1;``//frequency of arr[i]` `      `  `      ``if``(occur_time > 1 )``// elements that occur more than 1` `      ``{  i=last_index; ``//update i to last_index  ` `       ``cout<

## Python3

 `# Function to print elements that occur in arr more than once` `def` `printDuplicates(arr, n):` `    `  `    ``arr.sort()  ``# Sort array for binary search`   `    ``print``(``"["``, end``=``"")  ``# Print opening bracket`   `    ``i ``=` `0`  `# Initialize index` `    ``while` `i < n:`   `        ``# Index of first and last occurrence of arr[i]` `        ``first_index ``=` `arr.index(arr[i])` `        ``last_index ``=` `n ``-` `arr[::``-``1``].index(arr[i]) ``-` `1`   `        ``occur_time ``=` `last_index ``-` `first_index ``+` `1`  `# Frequency of arr[i]`   `        ``if` `occur_time > ``1``:  ``# If element occurs more than once` `            ``i ``=` `last_index  ``# Update i to last index` `            ``print``(arr[i], end``=``", "``)  ``# Print repeat element`   `        ``i ``+``=` `1`  `# Increment index`   `    ``print``(``"]"``)  ``# Print closing bracket`     `# Driver code` `arr ``=` `[``12``, ``11``, ``40``, ``12``, ``5``, ``6``, ``5``, ``12``, ``11``]` `n ``=` `len``(arr)`   `# Function call` `printDuplicates(arr, n)`

## Java

 `// Java implementation of the above approach`   `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `    ``// Function to find lower bound of target in arr` `    ``public` `static` `int` `lowerBound(``int``[] arr, ``int` `target)` `    ``{` `        ``int` `lo = ``0``, hi = arr.length - ``1``;` `        ``int` `ans = -``1``;` `        ``while` `(lo <= hi) {` `            ``int` `mid = lo + (hi - lo) / ``2``;` `            ``if` `(arr[mid] >= target) {` `                ``ans = mid;` `                ``hi = mid - ``1``;` `            ``}` `            ``else` `{` `                ``lo = mid + ``1``;` `            ``}` `        ``}` `        ``return` `ans;` `    ``}`   `    ``// Function to find upper bound of target in arr` `    ``public` `static` `int` `upperBound(``int``[] arr, ``int` `target)` `    ``{` `        ``int` `lo = ``0``, hi = arr.length - ``1``;` `        ``int` `ans = -``1``;` `        ``while` `(lo <= hi) {` `            ``int` `mid = lo + (hi - lo) / ``2``;` `            ``if` `(arr[mid] <= target) {` `                ``ans = mid;` `                ``lo = mid + ``1``;` `            ``}` `            ``else` `{` `                ``hi = mid - ``1``;` `            ``}` `        ``}` `        ``return` `ans;` `    ``}`   `    ``// Function to print elements that occur more than once` `    ``// in arr` `    ``static` `void` `printDuplicates(``int``[] arr, ``int` `n)` `    ``{` `        ``Arrays.sort(arr); ``// sort array for binary search`   `        ``System.out.print(``"["``);` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``// index of first and last occ of arr[i]` `            ``int` `firstIndex = lowerBound(arr, arr[i]);` `            ``int` `lastIndex = upperBound(arr, arr[i]);`   `            ``int` `occurTime = lastIndex - firstIndex` `                            ``+ ``1``; ``// frequency of arr[i]`   `            ``if` `(occurTime` `                ``> ``1``) { ``// elements that occur more than 1` `                ``i = lastIndex; ``// update i to last_index` `                ``System.out.print(arr[i] + ``", "``);` `            ``}` `        ``}` `        ``System.out.println(``"]"``);` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int``[] arr = { ``12``, ``11``, ``40``, ``12``, ``5``, ``6``, ``5``, ``12``, ``11` `};` `        ``int` `n = arr.length;`   `        ``// Function call` `        ``printDuplicates(arr, n);` `    ``}` `}`   `// This code is contributed by karthik.`

## Javascript

 `// Javascript implementation:`   `function` `printDuplicates(arr, n) {` `    ``// sort array for binary search` `    ``arr.sort();`   `    ``console.log(``"["``);` `    ``for` `(let i = 0; i < n; i++) ` `    ``{` `        ``// index of first and last occ of arr[i];` `        ``let first_index = arr.indexOf(arr[i]);` `        ``let last_index = arr.lastIndexOf(arr[i]);`   `        ``let occur_time = last_index - first_index + 1; ``//frequency of arr[i]`   `        ``if` `(occur_time > 1) { ``// elements that occur more than 1` `            ``i = last_index; ``//update i to last_index` `            ``console.log(arr[i] + ``", "``);` `        ``} ``// print repeat element` `    ``}` `    ``console.log(``"]"``);` `}`   `// Driver code` `let arr = [12, 11, 40, 12, 5, 6, 5, 12, 11];` `let n = arr.length;`   `// Function call` `printDuplicates(arr, n);`   `// This code is comtributed by akashish__`

Output

`[5, 11, 12, ]`

Time Complexity: O(n*log2n)
Auxiliary Space: O(1)

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.

My Personal Notes arrow_drop_up
Related Articles