Count Distinct ( Unique ) elements in an array
Last Updated :
26 Sep, 2023
Given an array arr[] of length N, The task is to count all distinct elements in arr[].
Examples:
Input: arr[] = {10, 20, 20, 10, 30, 10}
Output: 3
Explanation: There are three distinct elements 10, 20, and 30.
Input: arr[] = {10, 20, 20, 10, 20}
Output: 2
Naïve Approach:
Create a count variable and run two loops, one with counter i from 0 to N-1 to traverse arr[] and second with counter j from 0 to i-1 to check if ith element has appeared before. If yes, increment the count.
Below is the Implementation of the above approach.
C++
#include <iostream>
using namespace std;
int countDistinct( int arr[], int n)
{
int res = 1;
for ( int i = 1; i < n; i++) {
int j = 0;
for (j = 0; j < i; j++)
if (arr[i] == arr[j])
break ;
if (i == j)
res++;
}
return res;
}
int main()
{
int arr[] = { 12, 10, 9, 45, 2, 10, 10, 45 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << countDistinct(arr, n);
return 0;
}
|
Java
import java.io.*;
class GFG {
static int countDistinct( int arr[], int n)
{
int res = 1 ;
for ( int i = 1 ; i < n; i++) {
int j = 0 ;
for (j = 0 ; j < i; j++)
if (arr[i] == arr[j])
break ;
if (i == j)
res++;
}
return res;
}
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));
}
}
|
Python3
def countDistinct(arr, n):
res = 1
for i in range ( 1 , n):
j = 0
for j in range (i):
if (arr[i] = = arr[j]):
break
if (i = = j + 1 ):
res + = 1
return res
arr = [ 12 , 10 , 9 , 45 , 2 , 10 , 10 , 45 ]
n = len (arr)
print (countDistinct(arr, n))
|
C#
using System;
class GFG {
static int countDistinct( int [] arr, int n)
{
int res = 1;
for ( int i = 1; i < n; i++) {
int j = 0;
for (j = 0; j < i; j++)
if (arr[i] == arr[j])
break ;
if (i == j)
res++;
}
return res;
}
public static void Main()
{
int [] arr = { 12, 10, 9, 45, 2, 10, 10, 45 };
int n = arr.Length;
Console.WriteLine(countDistinct(arr, n));
}
}
|
Javascript
<script>
function countDistinct(arr, n)
{
let res = 1;
for (let i = 1; i < n; i++) {
let j = 0;
for (j = 0; j < i; j++)
if (arr[i] === arr[j])
break ;
if (i === j)
res++;
}
return res;
}
let arr = [ 12, 10, 9, 45, 2, 10, 10, 45 ];
let n = arr.length;
document.write(countDistinct(arr, n));
</script>
|
PHP
<?php
function countDistinct( & $arr , $n )
{
$res = 1;
for ( $i = 1; $i < $n ; $i ++)
{
for ( $j = 0; $j < $i ; $j ++)
if ( $arr [ $i ] == $arr [ $j ])
break ;
if ( $i == $j )
$res ++;
}
return $res ;
}
$arr = array ( 12, 10, 9, 45, 2, 10, 10, 45 );
$n = count ( $arr );
echo countDistinct( $arr , $n );
?>
|
Time Complexity: O(n2)
Auxiliary Space: O(1)
Below is the idea to solve the problem:
Sort the array so that all occurrences of every element become consecutive. Once the occurrences become consecutive, then traverse the sorted array and count distinct elements by comparing the consecutive elements.
Follow the steps below to Implement the idea:
- Initialize a res variable with 0 and sort arr[].
- Run a for loop from 0 to N-1.
- While i is less than N-1 and arr[i] is equal to arr[i+1] increment i.
- increment res by one.
- Return res.
Below is the implementation of above approach that is as follows:
C++
#include <algorithm>
#include <iostream>
using namespace std;
int countDistinct( int arr[], int n)
{
sort(arr, arr + n);
int res = 0;
for ( int i = 0; i < n; i++) {
while (i < n - 1 && arr[i] == arr[i + 1])
i++;
res++;
}
return res;
}
int main()
{
int arr[] = { 6, 10, 5, 4, 9, 120, 4, 6, 10 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << countDistinct(arr, n);
return 0;
}
|
Java
import java.util.Arrays;
class GFG {
static int countDistinct( int arr[], int n)
{
Arrays.sort(arr);
int res = 0 ;
for ( int i = 0 ; i < n; i++) {
while (i < n - 1 && arr[i] == arr[i + 1 ]) {
i++;
}
res++;
}
return res;
}
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));
}
}
|
Python3
def countDistinct(arr, n):
arr.sort()
res = 0
i = 0
while (i < n):
while (i < n - 1 and
arr[i] = = arr[i + 1 ]):
i + = 1
res + = 1
i + = 1
return res
arr = [ 6 , 10 , 5 , 4 , 9 , 120 , 4 , 6 , 10 ]
n = len (arr)
print (countDistinct(arr, n))
|
C#
using System;
class GFG {
static int countDistinct( int [] arr, int n)
{
Array.Sort(arr);
int res = 0;
for ( int i = 0; i < n; i++) {
while (i < n - 1 && arr[i] == arr[i + 1]) {
i++;
}
res++;
}
return res;
}
public static void Main()
{
int [] arr = { 6, 10, 5, 4, 9, 120, 4, 6, 10 };
int n = arr.Length;
Console.WriteLine(countDistinct(arr, n));
}
}
|
Javascript
<script>
function countDistinct(arr,n)
{
arr.sort( function (a,b){ return a-b;});
let res = 0;
for (let i = 0; i < n; i++)
{
while (i < n - 1 &&
arr[i] == arr[i + 1])
{
i++;
}
res++;
}
return res;
}
let arr=[6, 10, 5, 4, 9, 120, 4, 6, 10];
let n = arr.length;
document.write(countDistinct(arr, n));
</script>
|
PHP
<?php
function countDistinct( $arr , $n )
{
sort( $arr , 0);
$res = 0;
for ( $i = 0; $i < $n ; $i ++)
{
while ( $i < $n - 1 &&
$arr [ $i ] == $arr [ $i + 1])
$i ++;
$res ++;
}
return $res ;
}
$arr = array ( 6, 10, 5, 4, 9, 120, 4, 6, 10 );
$n = sizeof( $arr );
echo countDistinct( $arr , $n );
?>
|
Time Complexity: O(n logn)
Auxiliary Space: O(1)
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.
Follow the steps below to implement the idea:
- Create an unordered_set s and a variable res initialized with 0.
- Run a for loop from 0 to N-1
- If the current element is not present in s, insert it in s increment res by 1.
- Return res.
Below is the implementation of the above approach.
C++
#include <bits/stdc++.h>
using namespace std;
int countDistinct( int arr[], int n)
{
unordered_set< int > s;
int res = 0;
for ( int i = 0; i < n; i++) {
if (s.find(arr[i]) == s.end()) {
s.insert(arr[i]);
res++;
}
}
return res;
}
int main()
{
int arr[] = { 6, 10, 5, 4, 9, 120, 4, 6, 10 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << countDistinct(arr, n);
return 0;
}
|
Java
import java.util.*;
class GFG {
public static int countDistinct( int arr[], int n)
{
HashSet<Integer> hs = new HashSet<Integer>();
for ( int i = 0 ; i < n; i++) {
hs.add(arr[i]);
}
return hs.size();
}
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));
}
}
|
Python3
def countDistinct(arr, n):
s = set ()
res = 0
for i in range (n):
if (arr[i] not in s):
s.add(arr[i])
res + = 1
return res
arr = [ 6 , 10 , 5 , 4 , 9 , 120 , 4 , 6 , 10 ]
n = len (arr)
print (countDistinct(arr, n))
|
C#
using System;
using System.Collections.Generic;
class GFG {
public static int countDistinct( int [] arr, int n)
{
HashSet< int > hs = new HashSet< int >();
for ( int i = 0; i < n; i++) {
hs.Add(arr[i]);
}
return hs.Count;
}
public static void Main()
{
int [] arr
= new int [] { 6, 10, 5, 4, 9, 120, 4, 6, 10 };
Console.WriteLine(countDistinct(arr, arr.Length));
}
}
|
Javascript
<script>
function countDistinct(arr,n)
{
let hs = new Set();
for (let i = 0; i < n; i++)
{
hs.add(arr[i]);
}
return hs.size;
}
let arr=[6, 10, 5, 4, 9,120, 4, 6, 10];
document.write(countDistinct(arr,arr.length));
</script>
|
PHP
<?php
function countDistinct( $arr , $n )
{
$s = array ();
$res = 0;
for ( $i = 0; $i < $n ; $i ++)
{
array_push ( $s , $arr [ $i ]);
}
$s = array_unique ( $s );
return count ( $s );
}
$arr = array ( 6, 10, 5, 4, 9, 120, 4, 6, 10 );
$n = count ( $arr );
echo countDistinct( $arr , $n );
?>
|
Time complexity: O(n)
Auxiliary Space: O(n), since n extra space has been taken.
Iterate over all the elements of the array insert them in an unordered set. As the set only contains distinct elements, so the size of set will be the answer.
Follow the below steps to Implement the idea:
- Insert all the elements into the set S one by one.
- Store the total size s of the set using set::size().
- The total size s is the number of distinct elements present in the array.
Below is the Implementation of above approach.
C++
#include <bits/stdc++.h>
using namespace std;
int distinct( int * arr, int len)
{
set< int > S;
for ( int i = 0; i < len; i++) {
S.insert(arr[i]);
}
int ans = S.size();
return ans;
}
int main()
{
int arr[] = { 12, 10, 9, 45, 2, 10, 10, 45 };
int l = sizeof (arr) / sizeof ( int );
int dis_elements = distinct(arr, l);
cout << dis_elements << endl;
return 0;
}
|
Java
import java.util.*;
class GFG {
static int distinct( int [] arr, int len)
{
HashSet<Integer> S = new HashSet<>();
for ( int i = 0 ; i < len; i++) {
S.add(arr[i]);
}
int ans = S.size();
return ans;
}
public static void main(String[] args)
{
int arr[] = { 12 , 10 , 9 , 45 , 2 , 10 , 10 , 45 };
int l = arr.length;
int dis_elements = distinct(arr, l);
System.out.print(dis_elements + "\n" );
}
}
|
Python3
def distinct(arr, l):
S = set ()
for i in range (l):
S.add(arr[i])
ans = len (S)
return ans
if __name__ = = '__main__' :
arr = [ 12 , 10 , 9 , 45 , 2 , 10 , 10 , 45 ]
l = len (arr)
dis_elements = distinct(arr, l)
print (dis_elements, "")
|
C#
using System;
using System.Collections.Generic;
public class GFG {
static int distinct( int [] arr, int len)
{
HashSet< int > S = new HashSet< int >();
for ( int i = 0; i < len; i++) {
S.Add(arr[i]);
}
int ans = S.Count;
return ans;
}
public static void Main(String[] args)
{
int [] arr = { 12, 10, 9, 45, 2, 10, 10, 45 };
int l = arr.Length;
int dis_elements = distinct(arr, l);
Console.Write(dis_elements + "\n" );
}
}
|
Javascript
<script>
function distinct(arr , len)
{
var S = new Set();
var i =0;
for (i = 0; i < len; i++)
{
S.add(arr[i]);
}
var ans = S.size;
return ans;
}
var arr = [ 12, 10, 9, 45, 2, 10, 10, 45 ];
var l = arr.length;
var dis_elements = distinct(arr, l);
document.write(dis_elements);
</script>
|
Python one-liner approach using SET –
C++
#include <iostream>
#include <unordered_set>
using namespace std;
int main() {
int arr[] = { 12, 10, 9, 45, 2, 10, 10, 45 };
unordered_set< int > set;
for ( int i = 0; i < sizeof (arr) / sizeof (arr[0]); i++) {
set.insert(arr[i]);
}
cout << set.size() << endl;
return 0;
}
|
Java
import java.util.HashSet;
public class Program {
public static void main(String[] args)
{
int [] arr = { 12 , 10 , 9 , 45 , 2 , 10 , 10 , 45 };
HashSet<Integer> set = new HashSet<>();
for ( int i = 0 ; i < arr.length; i++) {
set.add(arr[i]);
}
System.out.println(set.size());
}
}
|
Python3
arr = [ 12 , 10 , 9 , 45 , 2 , 10 , 10 , 45 ]
print ( len ( set (arr)))
|
C#
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
int [] arr = { 12, 10, 9, 45, 2, 10, 10, 45 };
HashSet< int > set = new HashSet< int >();
foreach ( int num in arr)
{
set .Add(num);
}
Console.WriteLine( set .Count);
Environment.Exit(0);
}
}
|
Javascript
let arr = [12, 10, 9, 45, 2, 10, 10, 45]
console.log(( new Set(arr)).size)
|
Create the map and store the elements in the map with value as their frequency because duplicate cannot exist in map data structure. So all the values that has been inserted into the map will be distinct. Finally. the size of the map will give you the number of distinct elements in the array present in the given input array(or vector).
Implementation of the above Approach is given below:
C++
#include <bits/stdc++.h>
using namespace std;
int main() {
vector< int > arr = { 12, 10, 9, 45, 2, 10, 10, 45 };
map< int , int > distinct;
for ( int i = 0; i < arr.size(); i++){
distinct[arr[i]]++;
}
cout << distinct.size();
}
|
Java
import java.util.*;
public class Main {
public static void main(String[] args) {
int [] arr = { 12 , 10 , 9 , 45 , 2 , 10 , 10 , 45 };
Map<Integer, Integer> distinct = new HashMap<>();
for ( int num : arr) {
distinct.put(num, distinct.getOrDefault(num, 0 ) + 1 );
}
System.out.println(distinct.size());
}
}
|
Python3
from collections import defaultdict
arr = [ 12 , 10 , 9 , 45 , 2 , 10 , 10 , 45 ]
distinct = defaultdict( int )
for num in arr:
distinct[num] + = 1
print ( len (distinct))
|
Python
arr = [ 12 , 10 , 9 , 45 , 2 , 10 , 10 , 45 ]
dic = {}
for i in arr:
if i not in dic:
dic[i] = 1
else :
dic[i] + = 1
print ( len (dic.keys()))
|
C#
using System;
using System.Collections.Generic;
class MainClass {
public static void Main ( string [] args) {
int [] arr = {12, 10, 9, 45, 2, 10, 10, 45};
Dictionary< int , int > distinct = new Dictionary< int , int >();
foreach ( int num in arr) {
if (distinct.ContainsKey(num)) {
distinct[num]++;
} else {
distinct[num] = 1;
}
}
Console.WriteLine(distinct.Count);
}
}
|
Javascript
let arr = [12, 10, 9, 45, 2, 10, 10, 45];
let distinct = new Map();
for (let i = 0; i < arr.length; i++) {
let current = arr[i];
if (distinct.has(current)) {
distinct.set(current, distinct.get(current) + 1);
} else {
distinct.set(current, 1);
}
}
console.log(distinct.size);
|
Time Complexity: O(n*log(n))
Auxiliary Space: O(n)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...