Related Articles

# Count distinct elements in an array

• Difficulty Level : Medium
• Last Updated : 28 Jun, 2021

Given an unsorted array, count all distinct elements in it.
Examples:

```Input :   arr[] = {10, 20, 20, 10, 30, 10}
Output : 3
There are three distinct elements 10, 20 and 30.

Input :   arr[] = {10, 20, 20, 10, 20}
Output : 2```

A simple solution is to run two loops. For every element, check if it has appeared before. If yes, increment count of distinct elements.

## C++

 `// C++ program to count distinct elements``// in a given array``#include ``using` `namespace` `std;` `int` `countDistinct(``int` `arr[], ``int` `n)``{``    ``int` `res = 1;` `    ``// Pick all elements one by one``    ``for` `(``int` `i = 1; i < n; i++) {``        ``int` `j = 0;``        ``for` `(j = 0; j < i; j++)``            ``if` `(arr[i] == arr[j])``                ``break``;` `        ``// If not printed earlier, then print it``        ``if` `(i == j)``            ``res++;``    ``}``    ``return` `res;``}` `// Driver program to test above function``int` `main()``{``    ``int` `arr[] = { 12, 10, 9, 45, 2, 10, 10, 45 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << countDistinct(arr, n);``    ``return` `0;``}`

## Java

 `// Java program to count distinct``// elements in a given array``class` `GFG``{``    ` `static` `int` `countDistinct(``int` `arr[], ``int` `n)``{``    ``int` `res = ``1``;` `    ``// Pick all elements one by one``    ``for` `(``int` `i = ``1``; i < n; i++)``    ``{``        ``int` `j = ``0``;``        ``for` `(j = ``0``; j < i; j++)``            ``if` `(arr[i] == arr[j])``                ``break``;` `        ``// If not printed earlier,``        ``// then print it``        ``if` `(i == j)``            ``res++;``    ``}``    ``return` `res;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``12``, ``10``, ``9``, ``45``, ``2``, ``10``, ``10``, ``45` `};``    ``int` `n = arr.length;``    ``System.out.println(countDistinct(arr, n));``}``}` `// This code is contributed by Code_Mech.`

## Python3

 `# Python3 program to count distinct``# elements in a given array``def` `countDistinct(arr, n):` `    ``res ``=` `1` `    ``# Pick all elements one by one``    ``for` `i ``in` `range``(``1``, n):``        ``j ``=` `0``        ``for` `j ``in` `range``(i):``            ``if` `(arr[i] ``=``=` `arr[j]):``                ``break` `        ``# If not printed earlier, then print it``        ``if` `(i ``=``=` `j ``+` `1``):``            ``res ``+``=` `1``    ` `    ``return` `res` `# Driver Code``arr ``=` `[``12``, ``10``, ``9``, ``45``, ``2``, ``10``, ``10``, ``45``]``n ``=` `len``(arr)``print``(countDistinct(arr, n))` `# This code is contributed by Mohit Kumar`

## C#

 `// C# program to count distinct``// elements in a given array``using` `System;` `class` `GFG``{``    ` `static` `int` `countDistinct(``int` `[]arr, ``int` `n)``{``    ``int` `res = 1;` `    ``// Pick all elements one by one``    ``for` `(``int` `i = 1; i < n; i++)``    ``{``        ``int` `j = 0;``        ``for` `(j = 0; j < i; j++)``            ``if` `(arr[i] == arr[j])``                ``break``;` `        ``// If not printed earlier,``        ``// then print it``        ``if` `(i == j)``            ``res++;``    ``}``    ``return` `res;``}` `// Driver code``public` `static` `void` `Main()``{``    ``int` `[]arr = { 12, 10, 9, 45,``                  ``2, 10, 10, 45 };``    ``int` `n = arr.Length;``    ``Console.WriteLine(countDistinct(arr, n));``}``}` `// This code is contributed``// by Akanksha Rai`

## PHP

 ``

## Javascript

 ``
Output
`5`

Time Complexity of above solution is O(n2). We can Use Sorting to solve the problem in O(nLogn) time. The idea is simple, first sort the array so that all occurrences of every element become consecutive. Once the occurrences become consecutive, we can traverse the sorted array and count distinct elements in O(n) time. Following is the implementation of the idea.

## C++

 `// C++ program to count all distinct elements``// in a given array``#include ``#include ``using` `namespace` `std;` `int` `countDistinct(``int` `arr[], ``int` `n)``{``    ``// First sort the array so that all``    ``// occurrences become consecutive``    ``sort(arr, arr + n);` `    ``// Traverse the sorted array``    ``int` `res = 0;``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Move the index ahead while``        ``// there are duplicates``        ``while` `(i < n - 1 && arr[i] == arr[i + 1])``            ``i++;` `        ``res++;``    ``}` `    ``return` `res;``}` `// Driver program to test above function``int` `main()``{``    ``int` `arr[] = { 6, 10, 5, 4, 9, 120, 4, 6, 10 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << countDistinct(arr, n);``    ``return` `0;``}`

## Java

 `// Java program to count all distinct elements``// in a given array``import` `java.util.Arrays;` `class` `GFG``{` `    ``static` `int` `countDistinct(``int` `arr[], ``int` `n)``    ``{``        ``// First sort the array so that all``        ``// occurrences become consecutive``        ``Arrays.sort(arr);` `        ``// Traverse the sorted array``        ``int` `res = ``0``;``        ``for` `(``int` `i = ``0``; i < n; i++)``        ``{` `            ``// Move the index ahead while``            ``// there are duplicates``            ``while` `(i < n - ``1` `&&``                    ``arr[i] == arr[i + ``1``])``            ``{``                ``i++;``            ``}``            ``res++;``        ``}``        ``return` `res;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = {``6``, ``10``, ``5``, ``4``, ``9``, ``120``, ``4``, ``6``, ``10``};``        ``int` `n = arr.length;``        ``System.out.println(countDistinct(arr, n));``    ``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program to count all distinct``# elements in a given array` `def` `countDistinct(arr, n):` `    ``# First sort the array so that all``    ``# occurrences become consecutive``    ``arr.sort();` `    ``# Traverse the sorted array``    ``res ``=` `0``;``    ``i ``=` `0``;``    ``while``(i < n):` `        ``# Move the index ahead while``        ``# there are duplicates``        ``while` `(i < n ``-` `1` `and``               ``arr[i] ``=``=` `arr[i ``+` `1``]):``            ``i ``+``=` `1``;` `        ``res ``+``=` `1``;``        ``i ``+``=` `1``;` `    ``return` `res;` `# Driver Code``arr ``=` `[ ``6``, ``10``, ``5``, ``4``, ``9``, ``120``, ``4``, ``6``, ``10` `];``n ``=` `len``(arr);``print``(countDistinct(arr, n));` `# This code is contributed by mits`

## C#

 `// C# program to count all distinct elements``// in a given array``using` `System;` `class` `GFG``{` `    ``static` `int` `countDistinct(``int``[] arr, ``int` `n)``    ``{``        ``// First sort the array so that all``        ``// occurrences become consecutive``        ``Array.Sort(arr);` `        ``// Traverse the sorted array``        ``int` `res = 0;``        ``for` `(``int` `i = 0; i < n; i++)``        ``{` `            ``// Move the index ahead while``            ``// there are duplicates``            ``while` `(i < n - 1 &&``                    ``arr[i] == arr[i + 1])``            ``{``                ``i++;``            ``}``            ``res++;``        ``}``        ``return` `res;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int``[] arr = {6, 10, 5, 4, 9, 120, 4, 6, 10};``        ``int` `n = arr.Length;``        ``Console.WriteLine(countDistinct(arr, n));``    ``}``}` `// This code is contributed by Code_Mech.`

## PHP

 ``

## Javascript

 ``
Output
`6`

We can Use Hashing to solve this in O(n) time on average. The idea is to traverse the given array from left to right and keep track of visited elements in a hash set , as a set consists of only unique elements.
Following is the implementation of the idea.

## C++

 `/* CPP program to print all distinct elements``   ``of a given array */``#include ``using` `namespace` `std;` `// This function prints all distinct elements``int` `countDistinct(``int` `arr[], ``int` `n)``{``    ``// Creates an empty hashset``    ``unordered_set<``int``> s;` `    ``// Traverse the input array``    ``int` `res = 0;``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// If not present, then put it in``        ``// hashtable and increment result``        ``if` `(s.find(arr[i]) == s.end()) {``            ``s.insert(arr[i]);``            ``res++;``        ``}``    ``}` `    ``return` `res;``}` `// Driver program to test above function``int` `main()``{``    ``int` `arr[] = { 6, 10, 5, 4, 9, 120, 4, 6, 10 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << countDistinct(arr, n);``    ``return` `0;``}`

## Java

 `// Java Program to count``// Unique elements in Array``import` `java.util.*;` `class` `GFG``{``    ` `    ``// This method returns count``    ``// of Unique elements``    ``public` `static` `int` `countDistinct(``int` `arr[],``int` `n)``    ``{` `        ``HashSet hs = ``new` `HashSet();` `        ``for``(``int` `i = ``0``; i < n; i++)``        ``{``            ``// add all the elements to the HashSet``            ``hs.add(arr[i]);``        ``}``        ` `        ``// return the size of hashset as``        ``// it consists of all Unique elements``        ``return` `hs.size();    ``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = ``new` `int``[]{``6``, ``10``, ``5``, ``4``, ``9``,``                                ``120``, ``4``, ``6``, ``10``};``        ``System.out.println(countDistinct(arr,``                                ``arr.length));``    ``}``}` `// This code is contributed by Adarsh_Verma`

## Python3

 `''' Python3 program to prall distinct elements``of a given array '''` `# This function prints all distinct elements``def` `countDistinct(arr, n):` `    ``# Creates an empty hashset``    ``s ``=` `set``()``    ` `    ``# Traverse the input array``    ``res ``=` `0``    ``for` `i ``in` `range``(n):``    ` `        ``# If not present, then put it in``        ``# hashtable and increment result``        ``if` `(arr[i] ``not` `in` `s):``            ``s.add(arr[i])``            ``res ``+``=` `1``    ` `    ``return` `res` `# Driver code``arr ``=` `[``6``, ``10``, ``5``, ``4``, ``9``, ``120``, ``4``, ``6``, ``10``]``n ``=` `len``(arr)``print``(countDistinct(arr, n))` `# This code is contributed by SHUBHAMSINGH10`

## C#

 `// C# Program to count``// Unique elements in Array``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``    ` `    ``// This method returns count``    ``// of Unique elements``    ``public` `static` `int` `countDistinct(``int` `[]arr,``int` `n)``    ``{` `        ``HashSet<``int``> hs = ``new` `HashSet<``int``>();` `        ``for``(``int` `i = 0; i < n; i++)``        ``{``            ``// add all the elements to the HashSet``            ``hs.Add(arr[i]);``        ``}``        ` `        ``// return the size of hashset as``        ``// it consists of all Unique elements``        ``return` `hs.Count;    ``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int` `[]arr = ``new` `int``[]{6, 10, 5, 4, 9,``                                ``120, 4, 6, 10};``        ``Console.WriteLine(countDistinct(arr,``                                ``arr.Length));``    ``}``}` `/* This code contributed by PrinciRaj1992 */`

## PHP

 ``

## Javascript

 ``
Output
`6`

Set STL approach:

Sets are a type of associative containers in which each element has to be unique, because the value of the element identifies it. The value of the element cannot be modified once it is added to the set, though it is possible to remove and add the modified value of that element. We exploit the very basic property of set STL that it stores only unique numbers.

Examples:

Arr = [1,2,2,2,3,16,2,8,2,1,8]

Distinct elements present = [1,2,3,16,8]

Total number of distinct elements in the array are 5

Algorithm :

1. Insert all the elements into the set S one by one. 2.  Store the total size s of the set using set::size().

3.The total size s is the number of distinct elements present in the array.

## C++

 `#include ``using` `namespace` `std;``// function that accepts the array and it's size and returns``// the number of distince elements``int` `distinct(``int``* arr, ``int` `len)``{``    ``set<``int``> S; ``// declaring a set container using STL``    ``for` `(``int` `i = 0; i < len; i++) {``        ``S.insert(arr[i]); ``// inserting all elements of the``                          ``// array into set``    ``}``    ``int` `ans = S.size(); ``// calculating the size of the set``    ``return` `ans;``}``int` `main()``{``    ``int` `arr[] = { 12, 10, 9, 45, 2, 10, 10, 45};``    ``int` `l = ``sizeof``(arr)``            ``/ ``sizeof``(``                ``int``); ``// calculating the size of the array``    ``int` `dis_elements``        ``= distinct(arr, l); ``// calling the function on array``    ``cout << dis_elements << endl;``    ``return` `0;``}`
Output
`5`

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.

My Personal Notes arrow_drop_up