Least frequent element in an array
Given an array, find the least frequent element in it. If there are multiple elements that appear least number of times, print any one of them.
Examples :
Input : arr[] = {1, 3, 2, 1, 2, 2, 3, 1}
Output : 3
Explanation: 3 appears minimum number of times in given array.
Input : arr[] = {10, 20, 30}
Output : 10 or 20 or 30
A simple solution is to run two loops. The outer loop picks all elements one by one. The inner loop finds the frequency of the picked element and compares with the minimum so far.
C++
#include <bits/stdc++.h>
using namespace std;
int leastFrequent( int * arr, int n)
{
int mincount = INT_MAX;
int element_having_min_freq;
for ( int i = 0; i < n; i++) {
int count = 0;
for ( int j = 0; j < n; j++) {
if (arr[i] == arr[j])
count++;
}
if (count < mincount) {
mincount = count;
element_having_min_freq = arr[i];
}
}
return element_having_min_freq;
}
int main()
{
int arr[] = { 1, 3, 2, 1, 2, 2, 3, 1 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << leastFrequent(arr, n);
return 0;
}
|
Java
import java.io.*;
public class Main {
public static int INT_MAX = 1000000000 ;
public static int leastFrequent( int arr[], int n) {
int mincount = INT_MAX;
int element_having_min_freq = - 1 ;
for ( int i = 0 ; i < n; i++) {
int count = 0 ;
for ( int j = 0 ; j < n; j++) {
if (arr[i] == arr[j])
count++;
}
if (count < mincount) {
mincount = count;
element_having_min_freq = arr[i];
}
}
return element_having_min_freq;
}
public static void main(String[] args) {
int arr[] = { 1 , 3 , 2 , 1 , 2 , 2 , 3 , 1 };
int n = 8 ;
System.out.println(leastFrequent(arr, n));
}
}
|
Python3
class Main :
INT_MAX = 1000000000
@staticmethod
def leastFrequent( arr, n) :
mincount = Main.INT_MAX
element_having_min_freq = - 1
i = 0
while (i < n) :
count = 0
j = 0
while (j < n) :
if (arr[i] = = arr[j]) :
count + = 1
j + = 1
if (count < mincount) :
mincount = count
element_having_min_freq = arr[i]
i + = 1
return element_having_min_freq
@staticmethod
def main( args) :
arr = [ 1 , 3 , 2 , 1 , 2 , 2 , 3 , 1 ]
n = 8
print (Main.leastFrequent(arr, n))
if __name__ = = "__main__" :
Main.main([])
|
C#
using System;
public class GFG {
public static int INT_MAX = 1000000000;
public static int leastFrequent( int [] arr, int n) {
int mincount = INT_MAX;
int element_having_min_freq = -1;
for ( int i = 0; i < n; i++) {
int count = 0;
for ( int j = 0; j < n; j++) {
if (arr[i] == arr[j])
count++;
}
if (count < mincount) {
mincount = count;
element_having_min_freq = arr[i];
}
}
return element_having_min_freq;
}
public static void Main( string [] args) {
int [] arr = { 1, 3, 2, 1, 2, 2, 3, 1 };
int n = 8;
Console.WriteLine(leastFrequent(arr, n));
}
}
|
Javascript
function leastFrequent(arr, n)
{
let mincount = Number.MAX_VALUE;
let element_having_min_freq;
for (let i = 0; i < n; i++) {
let count = 0;
for (let j = 0; j < n; j++) {
if (arr[i] == arr[j])
count++;
}
if (count < mincount) {
mincount = count;
element_having_min_freq = arr[i];
}
}
return element_having_min_freq;
}
let arr = [ 1, 3, 2, 1, 2, 2, 3, 1 ];
let n = 8;
console.log(leastFrequent(arr, n));
|
Time Complexity: O(n2)
Auxiliary Space: O(1)
A better solution is to do sorting. We first sort the array, then linearly traverse the array.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
int leastFrequent( int arr[], int n)
{
sort(arr, arr + n);
int min_count = n + 1, res = -1, curr_count = 1;
for ( int i = 1; i < n; i++) {
if (arr[i] == arr[i - 1])
curr_count++;
else {
if (curr_count < min_count) {
min_count = curr_count;
res = arr[i - 1];
}
curr_count = 1;
}
}
if (curr_count < min_count) {
min_count = curr_count;
res = arr[n - 1];
}
return res;
}
int main()
{
int arr[] = { 1, 3, 2, 1, 2, 2, 3, 1 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << leastFrequent(arr, n);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG {
static int leastFrequent( int arr[], int n)
{
Arrays.sort(arr);
int min_count = n + 1 , res = - 1 ;
int curr_count = 1 ;
for ( int i = 1 ; i < n; i++) {
if (arr[i] == arr[i - 1 ])
curr_count++;
else {
if (curr_count < min_count) {
min_count = curr_count;
res = arr[i - 1 ];
}
curr_count = 1 ;
}
}
if (curr_count < min_count) {
min_count = curr_count;
res = arr[n - 1 ];
}
return res;
}
public static void main(String args[])
{
int arr[] = { 1 , 3 , 2 , 1 , 2 , 2 , 3 , 1 };
int n = arr.length;
System.out.print(leastFrequent(arr, n));
}
}
|
Python3
def leastFrequent(arr, n):
arr.sort()
min_count = n + 1
res = - 1
curr_count = 1
for i in range ( 1 , n):
if (arr[i] = = arr[i - 1 ]):
curr_count = curr_count + 1
else :
if (curr_count < min_count):
min_count = curr_count
res = arr[i - 1 ]
curr_count = 1
if (curr_count < min_count):
min_count = curr_count
res = arr[n - 1 ]
return res
arr = [ 1 , 3 , 2 , 1 , 2 , 2 , 3 , 1 ]
n = len (arr)
print (leastFrequent(arr, n))
|
C#
using System;
class GFG {
static int leastFrequent( int [] arr, int n)
{
Array.Sort(arr);
int min_count = n + 1, res = -1;
int curr_count = 1;
for ( int i = 1; i < n; i++) {
if (arr[i] == arr[i - 1])
curr_count++;
else {
if (curr_count < min_count) {
min_count = curr_count;
res = arr[i - 1];
}
curr_count = 1;
}
}
if (curr_count < min_count) {
min_count = curr_count;
res = arr[n - 1];
}
return res;
}
static public void Main()
{
int [] arr = { 1, 3, 2, 1, 2, 2, 3, 1 };
int n = arr.Length;
Console.Write(leastFrequent(arr, n));
}
}
|
PHP
<?php
function leastFrequent( $arr , $n )
{
sort( $arr );
sort( $arr , $n );
$min_count = $n + 1;
$res = -1;
$curr_count = 1;
for ( $i = 1; $i < $n ; $i ++)
{
if ( $arr [ $i ] == $arr [ $i - 1])
$curr_count ++;
else
{
if ( $curr_count < $min_count )
{
$min_count = $curr_count ;
$res = $arr [ $i - 1];
}
$curr_count = 1;
}
}
if ( $curr_count < $min_count )
{
$min_count = $curr_count ;
$res = $arr [ $n - 1];
}
return $res ;
}
{
$arr = array (1, 3, 2, 1, 2, 2, 3, 1);
$n = sizeof( $arr ) / sizeof( $arr [0]);
echo leastFrequent( $arr , $n );
return 0;
}
?>
|
Javascript
function leastFrequent(arr, n) {
arr.sort();
let min_count = n + 1,
res = -1;
let curr_count = 1;
for (let i = 1; i < n; i++) {
if (arr[i] == arr[i - 1]) curr_count++;
else {
if (curr_count < min_count) {
min_count = curr_count;
res = arr[i - 1];
}
curr_count = 1;
}
}
if (curr_count < min_count) {
min_count = curr_count;
res = arr[n - 1];
}
return res;
}
let arr = [1, 3, 2, 1, 2, 2, 3, 1];
let n = arr.length;
console.log(leastFrequent(arr, n));
|
Time Complexity: O(n Log n)
Auxiliary Space: O(1)
An efficient solution is to use hashing. We create a hash table and store elements and their frequency counts as key value pairs. Finally we traverse the hash table and print the key with minimum value.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
int leastFrequent( int arr[], int n)
{
unordered_map< int , int > hash;
for ( int i = 0; i < n; i++)
hash[arr[i]]++;
int min_count = n + 1, res = -1;
for ( auto i : hash) {
if (min_count >= i.second) {
res = i.first;
min_count = i.second;
}
}
return res;
}
int main()
{
int arr[] = { 1, 3, 2, 1, 2, 2, 3, 1 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << leastFrequent(arr, n);
return 0;
}
|
Java
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
class GFG {
static int leastFrequent( int arr[], int n)
{
Map<Integer, Integer> count
= new HashMap<Integer, Integer>();
for ( int i = 0 ; i < n; i++) {
int key = arr[i];
if (count.containsKey(key)) {
int freq = count.get(key);
freq++;
count.put(key, freq);
}
else
count.put(key, 1 );
}
int min_count = n + 1 , res = - 1 ;
for (Entry<Integer, Integer> val :
count.entrySet()) {
if (min_count >= val.getValue()) {
res = val.getKey();
min_count = val.getValue();
}
}
return res;
}
public static void main(String[] args)
{
int arr[] = { 1 , 3 , 2 , 1 , 2 , 2 , 3 , 1 };
int n = arr.length;
System.out.println(leastFrequent(arr, n));
}
}
|
Python3
import math as mt
def leastFrequent(arr, n):
Hash = dict ()
for i in range (n):
if arr[i] in Hash .keys():
Hash [arr[i]] + = 1
else :
Hash [arr[i]] = 1
min_count = n + 1
res = - 1
for i in Hash :
if (min_count > = Hash [i]):
res = i
min_count = Hash [i]
return res
arr = [ 1 , 3 , 2 , 1 , 2 , 2 , 3 , 1 ]
n = len (arr)
print (leastFrequent(arr, n))
|
C#
using System;
using System.Collections.Generic;
class GFG {
static int leastFrequent( int [] arr, int n)
{
Dictionary< int , int > count
= new Dictionary< int , int >();
for ( int i = 0; i < n; i++) {
int key = arr[i];
if (count.ContainsKey(key)) {
int freq = count[key];
freq++;
count[key] = freq;
}
else
count.Add(key, 1);
}
int min_count = n + 1, res = -1;
foreach (KeyValuePair< int , int > pair in count)
{
if (min_count >= pair.Value) {
res = pair.Key;
min_count = pair.Value;
}
}
return res;
}
static void Main()
{
int [] arr = new int [] { 1, 3, 2, 1, 2, 2, 3, 1 };
int n = arr.Length;
Console.Write(leastFrequent(arr, n));
}
}
|
Javascript
function leastFrequent(arr, n) {
let count = new Map();
for (let i = 0; i < n; i++) {
let key = arr[i];
if (count.has(key)) {
let freq = count.get(key);
freq++;
count.set(key, freq);
} else count.set(key, 1);
}
let min_count = n + 1,
res = -1;
for (let [key, val] of count.entries()) {
if (min_count >= val) {
res = key;
min_count = val;
}
}
return res;
}
let arr = [1, 3, 2, 1, 2, 2, 3, 1];
let n = arr.length;
console.log(leastFrequent(arr, n));
|
Time Complexity: O(n)
Auxiliary Space: O(n)
Last Updated :
15 Mar, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...