Least frequent element in an array (original) (raw)

Last Updated : 15 Mar, 2023

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++ `

// CPP program to find the least frequent element in an // array. #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;

}

// Driver program 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

// Java program to find the least frequent element in an array. 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;

}

// Driver program 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)); } }

// This code is contributed by ajaymakvana.

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 # Driver program @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([])

# This code is contributed by aadityaburujwale.

C#

// C# program to find the least frequent element in an array. 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;

}

// Driver program public static void Main(string[] args) { int[] arr = { 1, 3, 2, 1, 2, 2, 3, 1 }; int n = 8; Console.WriteLine(leastFrequent(arr, n)); } }

// This code is contributed by ajaymakavana.

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;

}

// Driver program let arr = [ 1, 3, 2, 1, 2, 2, 3, 1 ]; let n = 8; console.log(leastFrequent(arr, n));

// This code is contributed by garg28harsh.

`

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++ `

// CPP program to find the least frequent element // in an array. #include <bits/stdc++.h> using namespace std;

int leastFrequent(int arr[], int n) { // Sort the array sort(arr, arr + n);

// find the min frequency using linear traversal
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 last element is least frequent
if (curr_count < min_count) {
    min_count = curr_count;
    res = arr[n - 1];
}

return res;

}

// driver program 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

// Java program to find the least frequent element // in an array. import java.io.; import java.util.;

class GFG {

static int leastFrequent(int arr[], int n)
{

    // Sort the array
    Arrays.sort(arr);

    // find the min frequency using
    // linear traversal
    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 last element is least frequent
    if (curr_count < min_count) {
        min_count = curr_count;
        res = arr[n - 1];
    }

    return res;
}

// driver program
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));
}

}

/This code is contributed by Nikita Tiwari./

Python3

Python 3 program to find the least

frequent element in an array.

def leastFrequent(arr, n):

# Sort the array
arr.sort()

# find the min frequency using
# linear traversal
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 last element is least frequent
if (curr_count < min_count):
    min_count = curr_count
    res = arr[n - 1]

return res

Driver program

arr = [1, 3, 2, 1, 2, 2, 3, 1] n = len(arr) print(leastFrequent(arr, n))

This code is contributed

by Nikita Tiwari.

C#

// C# program to find the least // frequent element in an array. using System;

class GFG {

static int leastFrequent(int[] arr, int n)
{
    // Sort the array
    Array.Sort(arr);

    // find the min frequency
    // using linear traversal
    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 last element is least frequent
    if (curr_count < min_count) {
        min_count = curr_count;
        res = arr[n - 1];
    }

    return res;
}

// Driver code
static public void Main()
{
    int[] arr = { 1, 3, 2, 1, 2, 2, 3, 1 };
    int n = arr.Length;

    // Function calling
    Console.Write(leastFrequent(arr, n));
}

}

// This code is contributed by Shrikant13

PHP

JavaScript

// Javascript program to find the least frequent element // in an array. function leastFrequent(arr, n) { // Sort the array arr.sort();

// find the min frequency using
// linear traversal
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 last element is least frequent
if (curr_count < min_count) {
    min_count = curr_count;
    res = arr[n - 1];
}

return res;

}

// driver program let arr = [1, 3, 2, 1, 2, 2, 3, 1]; let n = arr.length; console.log(leastFrequent(arr, n)); //This Code is contributed by chinmaya121221

`

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++ `

// CPP program to find the least frequent element // in an array. #include <bits/stdc++.h> using namespace std;

int leastFrequent(int arr[], int n) { // Insert all elements in hash. unordered_map<int, int> hash; for (int i = 0; i < n; i++) hash[arr[i]]++;

// find the min frequency
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;

}

// driver program 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

// Java program to find the least frequent element // in an array import java.util.HashMap; import java.util.Map; import java.util.Map.Entry;

class GFG {

static int leastFrequent(int arr[], int n)
{

    // Insert all elements in hash.
    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);
    }

    // find min frequency.
    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;
}

// driver program
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));
}

}

// This code is contributed by Akash Singh.

Python3

Python3 program to find the most

frequent element in an array.

import math as mt

def leastFrequent(arr, n):

# Insert all elements in Hash.
Hash = dict()
for i in range(n):
    if arr[i] in Hash.keys():
        Hash[arr[i]] += 1
    else:
        Hash[arr[i]] = 1

# find the max frequency
min_count = n + 1
res = -1
for i in Hash:
    if (min_count >= Hash[i]):
        res = i
        min_count = Hash[i]

return res

Driver Code

arr = [1, 3, 2, 1, 2, 2, 3, 1] n = len(arr) print(leastFrequent(arr, n))

This code is contributed by

mohit kumar 29

C#

// C# program to find the // least frequent element // in an array. using System; using System.Collections.Generic;

class GFG { static int leastFrequent(int[] arr, int n) { // Insert all elements in hash. 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); }

    // find the min frequency
    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;
}

// Driver Code
static void Main()
{
    int[] arr = new int[] { 1, 3, 2, 1, 2, 2, 3, 1 };
    int n = arr.Length;
    Console.Write(leastFrequent(arr, n));
}

}

// This code is contributed by // Manish Shaw(manishshaw1)

JavaScript

// Javascript program to find the least frequent element // in an array function leastFrequent(arr, n) { // Insert all elements in hash. 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);
}

// find min frequency.
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;

}

// driver program let arr = [1, 3, 2, 1, 2, 2, 3, 1]; let n = arr.length; console.log(leastFrequent(arr, n)); //This code is contributed by chinmaya121221

`

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