Skip to content

JavaScript - Counting Frequencies of Array Elements

Counting frequencies of array elements

Last Updated : 03 Oct, 2023

Given an array which may contain duplicates, print all elements and their frequencies.

Examples:

Input :  arr[] = {10, 20, 20, 10, 10, 20, 5, 20}
Output : 10 3
         20 4
         5  1

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

A simple solution is to run two loops. For every item count number of times, it occurs. To avoid duplicate printing, keep track of processed items.

Implementation:

C++

   // CPP program to count frequencies of array items
#include <bits/stdc++.h>
using namespace std;
 
void countFreq(int arr[], int n)
{
    // Mark all array elements as not visited
    vector<bool> visited(n, false);
 
    // Traverse through array elements and
    // count frequencies
    for (int i = 0; i < n; i++) {
 
        // Skip this element if already processed
        if (visited[i] == true)
            continue;
 
        // Count frequency
        int count = 1;
        for (int j = i + 1; j < n; j++) {
            if (arr[i] == arr[j]) {
                visited[j] = true;
                count++;
            }
        }
        cout << arr[i] << " " << count << endl;
    }
}
 
int main()
{
    int arr[] = { 10, 20, 20, 10, 10, 20, 5, 20 };
    int n = sizeof(arr) / sizeof(arr[0]);
    countFreq(arr, n);
    return 0;
}
 
  

Java

   // Java program to count frequencies of array items
import java.util.Arrays;
 
class GFG
{
public static void countFreq(int arr[], int n)
{
    boolean visited[] = new boolean[n];
     
    Arrays.fill(visited, false);
 
    // Traverse through array elements and
    // count frequencies
    for (int i = 0; i < n; i++) {
 
        // Skip this element if already processed
        if (visited[i] == true)
            continue;
 
        // Count frequency
        int count = 1;
        for (int j = i + 1; j < n; j++) {
            if (arr[i] == arr[j]) {
                visited[j] = true;
                count++;
            }
        }
        System.out.println(arr[i] + " " + count);
    }
}
 
// Driver code
public static void main(String []args)
{
    int arr[] = new int[]{ 10, 20, 20, 10, 10, 20, 5, 20 };
    int n = arr.length;
    countFreq(arr, n);
}
}
 
// This code contributed by Adarsh_Verma.
 
  

Python3

   # Python 3 program to count frequencies
# of array items
def countFreq(arr, n):
     
    # Mark all array elements as not visited
    visited = [False for i in range(n)]
 
    # Traverse through array elements 
    # and count frequencies
    for i in range(n):
         
        # Skip this element if already 
        # processed
        if (visited[i] == True):
            continue
 
        # Count frequency
        count = 1
        for j in range(i + 1, n, 1):
            if (arr[i] == arr[j]):
                visited[j] = True
                count += 1
         
        print(arr[i], count)
 
# Driver Code
if __name__ == '__main__':
    arr = [10, 20, 20, 10, 10, 20, 5, 20]
    n = len(arr)
    countFreq(arr, n)
     
# This code is contributed by
# Shashank_Sharma
 
  

C#

   // C# program to count frequencies of array items
using System;
 
class GFG
{
    public static void countFreq(int []arr, int n)
    {
        bool []visited = new bool[n];
     
        // Traverse through array elements and
        // count frequencies
        for (int i = 0; i < n; i++)
        {
     
            // Skip this element if already processed
            if (visited[i] == true)
                continue;
     
            // Count frequency
            int count = 1;
            for (int j = i + 1; j < n; j++) 
            {
                if (arr[i] == arr[j]) 
                {
                    visited[j] = true;
                    count++;
                }
            }
            Console.WriteLine(arr[i] + " " + count);
        }
    }
     
    // Driver code
    public static void Main(String []args)
    {
        int []arr = new int[]{ 10, 20, 20, 10, 10, 20, 5, 20 };
        int n = arr.Length;
        countFreq(arr, n);
    }
}
 
// This code has been contributed by 29AjayKumar
 
  

Javascript

   <script>
 
// JavaScript program to count frequencies of array items
 
function countFreq(arr, n)
{
    let visited = Array.from({length: n}, (_, i) => false);
         
    // Traverse through array elements and
    // count frequencies
    for (let i = 0; i < n; i++) {
   
        // Skip this element if already processed
        if (visited[i] == true)
            continue;
   
        // Count frequency
        let count = 1;
        for (let j = i + 1; j < n; j++) {
            if (arr[i] == arr[j]) {
                visited[j] = true;
                count++;
            }
        }
           document.write(arr[i] + " " + count + "<br/>");
    }
}
 
// Driver Code
 
    let arr = [ 10, 20, 20, 10, 10, 20, 5, 20 ];
    let n = arr.length;
    countFreq(arr, n);    
 
</script>
 
  

Output

10 3 20 4 5 1

Complexity Analysis:

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

An efficient solution is to use hashing.

Implementation:

C++

   // CPP program to count frequencies of array items
#include <bits/stdc++.h>
using namespace std;
 
void countFreq(int arr[], int n)
{
    unordered_map<int, int> mp;
 
    // Traverse through array elements and
    // count frequencies
    for (int i = 0; i < n; i++)
        mp[arr[i]]++;
 
    // Traverse through map and print frequencies
    for (auto x : mp)
        cout << x.first << " " << x.second << endl;
}
 
int main()
{
    int arr[] = { 10, 20, 20, 10, 10, 20, 5, 20 };
    int n = sizeof(arr) / sizeof(arr[0]);
    countFreq(arr, n);
    return 0;
}
 
  

Java

   // Java program to count frequencies of array items
import java.util.*;
 
class GFG
{
 
    static void countFreq(int arr[], int n)
    {
        Map<Integer, Integer> mp = new HashMap<>();
 
        // Traverse through array elements and
        // count frequencies
        for (int i = 0; i < n; i++)
        {
            if (mp.containsKey(arr[i])) 
            {
                mp.put(arr[i], mp.get(arr[i]) + 1);
            } 
            else
            {
                mp.put(arr[i], 1);
            }
        }
        // Traverse through map and print frequencies
        for (Map.Entry<Integer, Integer> entry : mp.entrySet())
        {
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
    }
 
    // Driver code
    public static void main(String args[]) 
    {
        int arr[] = {10, 20, 20, 10, 10, 20, 5, 20};
        int n = arr.length;
        countFreq(arr, n);
    }
}
 
// This code contributed by Rajput-Ji
 
  

Python3

   # Python3 program to count frequencies 
# of array items
def countFreq(arr, n):
 
    mp = dict()
 
    # Traverse through array elements 
    # and count frequencies
    for i in range(n):
        if arr[i] in mp.keys():
            mp[arr[i]] += 1
        else:
            mp[arr[i]] = 1
             
    # Traverse through map and print 
    # frequencies
    for x in mp:
        print(x, " ", mp[x])
 
# Driver code
arr = [10, 20, 20, 10, 10, 20, 5, 20 ]
n = len(arr)
countFreq(arr, n)
 
# This code is contributed by 
# Mohit kumar 29
 
  

C#

   // C# implementation of the approach
using System;
using System.Collections.Generic; 
 
class GFG
{
 
    static void countFreq(int []arr, int n)
    {
        Dictionary<int, int> mp = new Dictionary<int,int>();
 
        // Traverse through array elements and
        // count frequencies
        for (int i = 0; i < n; i++)
        {
            if (mp.ContainsKey(arr[i])) 
            {
                var val = mp[arr[i]];
                mp.Remove(arr[i]);
                mp.Add(arr[i], val + 1); 
            } 
            else
            {
                mp.Add(arr[i], 1);
            }
        }
         
        // Traverse through map and print frequencies
        foreach(KeyValuePair<int, int> entry in mp)
        {
            Console.WriteLine(entry.Key + " " + entry.Value);
        }
    }
 
    // Driver code
    public static void Main(String []args) 
    {
        int []arr = {10, 20, 20, 10, 10, 20, 5, 20};
        int n = arr.Length;
        countFreq(arr, n);
    }
}
 
/* This code contributed by PrinciRaj1992 */
 
  

Javascript

   <script>
 
 
// JavaScript program to count 
// frequencies of array items
 
 
 
function countFreq(arr, n)
{
    const map ={}
 
    // Traverse through array elements and
    // count frequencies
    for (let i = 0; i < n; i++)
    {
       if(map[arr[i]){
          map[arr[i]]+=1
       }
        else{
           map[arr[i]] =1
         }
    }
   console.log(map)
}
var arr = [10, 20, 20, 10, 10, 20, 5, 20];
var n = arr.length;
countFreq(arr, n);
 
</script>
 
  

Output

5 1 20 4 10 3

Complexity Analysis:

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

In the above efficient solution, how to print elements in same order as they appear in input?

Implementation:

C++

   // CPP program to count frequencies of array items
#include <bits/stdc++.h>
using namespace std;
 
void countFreq(int arr[], int n)
{
    unordered_map<int, int> mp;
 
    // Traverse through array elements and
    // count frequencies
    for (int i = 0; i < n; i++)
        mp[arr[i]]++;
 
    // To print elements according to first
    // occurrence, traverse array one more time
    // print frequencies of elements and mark
    // frequencies as -1 so that same element
    // is not printed multiple times.
    for (int i = 0; i < n; i++) {
      if (mp[arr[i]] != -1)
      {
          cout << arr[i] << " " << mp[arr[i]] << endl;
          mp[arr[i]] = -1;
      }
    }
}
 
int main()
{
    int arr[] = { 10, 20, 20, 10, 10, 20, 5, 20 };
    int n = sizeof(arr) / sizeof(arr[0]);
    countFreq(arr, n);
    return 0;
}
 
  

Java

   // Java program to count frequencies of array items 
import java.util.*;
 
class GFG 
{
 
    static void countFreq(int arr[], int n) 
    {
        Map<Integer, Integer> mp = new HashMap<>();
 
        // Traverse through array elements and 
        // count frequencies 
        for (int i = 0; i < n; i++)
        {
            mp.put(arr[i], mp.get(arr[i]) == null ? 1 : mp.get(arr[i]) + 1);
        }
 
        // To print elements according to first 
        // occurrence, traverse array one more time 
        // print frequencies of elements and mark 
        // frequencies as -1 so that same element 
        // is not printed multiple times. 
        for (int i = 0; i < n; i++) 
        {
            if (mp.get(arr[i]) != -1) 
            {
                System.out.println(arr[i] + " " + mp.get(arr[i]));
                mp.put(arr[i], -1);
            }
        }
    }
 
    // Driver code
    public static void main(String[] args) 
    {
        int arr[] = {10, 20, 20, 10, 10, 20, 5, 20};
        int n = arr.length;
        countFreq(arr, n);
    }
}
 
// This code contributed by Rajput-Ji
 
  

Python3

   # Python3 program to count frequencies of array items
def countFreq(arr, n):
     
    mp = {}
     
    # Traverse through array elements and
    # count frequencies
    for i in range(n):
        if arr[i] not in mp:
            mp[arr[i]] = 0
        mp[arr[i]] += 1
         
    # To print elements according to first
    # occurrence, traverse array one more time
    # print frequencies of elements and mark
    # frequencies as -1 so that same element
    # is not printed multiple times.
    for i in range(n):
        if (mp[arr[i]] != -1):
            print(arr[i],mp[arr[i]])
        mp[arr[i]] = -1
 
# Driver code
 
arr = [10, 20, 20, 10, 10, 20, 5, 20]
n = len(arr)
countFreq(arr, n)
 
# This code is contributed by shubhamsingh10
 
  

C#

   // C# program to count frequencies of array items 
using System;
using System.Collections.Generic;
 
class GFG 
{ 
 
    static void countFreq(int []arr, int n) 
    { 
        Dictionary<int,int> mp = new Dictionary<int,int>(); 
 
        // Traverse through array elements and 
        // count frequencies 
         
        for (int i = 0 ; i < n; i++)
        {
            if(mp.ContainsKey(arr[i]))
            {
                var val = mp[arr[i]];
                mp.Remove(arr[i]);
                mp.Add(arr[i], val + 1); 
            }
            else
            {
                mp.Add(arr[i], 1);
            }
        }
 
        // To print elements according to first 
        // occurrence, traverse array one more time 
        // print frequencies of elements and mark 
        // frequencies as -1 so that same element 
        // is not printed multiple times. 
        for (int i = 0; i < n; i++) 
        { 
            if (mp.ContainsKey(arr[i]) && mp[arr[i]] != -1) 
            { 
                Console.WriteLine(arr[i] + " " + mp[arr[i]]); 
                mp.Remove(arr[i]);
                mp.Add(arr[i], -1); 
            } 
        } 
    } 
 
    // Driver code 
    public static void Main(String[] args) 
    { 
        int []arr = {10, 20, 20, 10, 10, 20, 5, 20}; 
        int n = arr.Length; 
        countFreq(arr, n); 
    } 
} 
 
// This code is contributed by Princi Singh
 
  

Javascript

   <script>
 
 
// Javascript program to count frequencies of array items
 
function countFreq(arr, n)
{
    var mp = new Map();
 
    // Traverse through array elements and
    // count frequencies
    for (var i = 0; i < n; i++)
    {
        if(mp.has(arr[i]))
            mp.set(arr[i], mp.get(arr[i])+1)
        else
            mp.set(arr[i], 1)
    }
     
    // To print elements according to first
    // occurrence, traverse array one more time
    // print frequencies of elements and mark
    // frequencies as -1 so that same element
    // is not printed multiple times.
    for (var i = 0; i < n; i++) {
      if (mp.get(arr[i]) != -1)
      {
          document.write( arr[i] + " " + mp.get(arr[i]) + "<br>");
          mp.set(arr[i], -1);
      }
    }
}
 
var arr = [10, 20, 20, 10, 10, 20, 5, 20];
var n = arr.length;
countFreq(arr, n);
 
// This code is contributed by rrrtnx.
</script>
 
  

Output

10 3 20 4 5 1

Complexity Analysis:

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

This problem can be solved in Java using Hashmap. Below is the program.

Implementation:

C++

   // C++ program to count frequencies of
// integers in array using Hashmap
#include <bits/stdc++.h>
using namespace std;
 
void frequencyNumber(int arr[],int size)
{
   
  // Creating a HashMap containing integer
  // as a key and occurrences as a value
  unordered_map<int,int>freqMap;
 
  for (int i=0;i<size;i++) {
    freqMap[arr[i]]++;
  }
 
  // Printing the freqMap
  for (auto it : freqMap) {
    cout<<it.first<<" "<<it.second<<endl;
  }
}
 
int main()
{
  int arr[] = {10, 20, 20, 10, 10, 20, 5, 20};
  int size = sizeof(arr)/sizeof(arr[0]);
  frequencyNumber(arr,size);
}
 
// This code is contributed by shinjanpatra.
 
  

Java

   // Java program to count frequencies of
// integers in array using Hashmap
import java.io.*;
import java.util.*;
class OccurenceOfNumberInArray {
    static void frequencyNumber(int arr[], int size)
    {
        // Creating a HashMap containing integer
        // as a key and occurrences as a value
        HashMap<Integer, Integer> freqMap
            = new HashMap<Integer, Integer>();
 
        for (int i=0;i<size;i++) {
            if (freqMap.containsKey(arr[i])) {
 
                // If number is present in freqMap,
                // incrementing it's count by 1
                freqMap.put(arr[i], freqMap.get(arr[i]) + 1);
            }
            else {
 
                // If integer is not present in freqMap,
                // putting this integer to freqMap with 1 as it's value
                freqMap.put(arr[i], 1);
            }
        }
 
        // Printing the freqMap
        for (Map.Entry entry : freqMap.entrySet()) {
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int arr[] = {10, 20, 20, 10, 10, 20, 5, 20};
        int size = arr.length;
        frequencyNumber(arr,size);
    }
}
 
  

Python3

   # Python program to count frequencies of
# integers in array using Hashmap
 
def frequencyNumber(arr,size):
    # Creating a HashMap containing integer
        # as a key and occurrences as a value
        freqMap = {}
  
        for i in range(size):
            if (arr[i] in freqMap):
  
                # If number is present in freqMap,
                # incrementing it's count by 1
                freqMap[arr[i]] = freqMap[arr[i]] + 1
            else:
  
                # If integer is not present in freqMap,
                # putting this integer to freqMap with 1 as it's value
                freqMap[arr[i]] = 1
  
        # Printing the freqMap
        for key, value in freqMap.items():
            print(f"{key} {value}")
 
# Driver Code
arr = [10, 20, 20, 10, 10, 20, 5, 20]
size = len(arr)
frequencyNumber(arr,size)
 
# This code is contributed by shinjanpatra
 
  

C#

   // C# program to count frequencies of
// integers in array using Hashmap
using System;
using System.Collections.Generic; 
class GFG
{
  static void frequencyNumber(int []arr,int size)
  {
 
    // Creating a Dictionary containing integer
    // as a key and occurrences as a value
    Dictionary<int, int> freqMap = new Dictionary<int,int>();
 
    for(int i = 0; i < size; i++){
      if (freqMap.ContainsKey(arr[i])) 
      {
        var val = freqMap[arr[i]];
        freqMap.Remove(arr[i]);
        freqMap.Add(arr[i], val + 1); 
      } 
      else
      {
        freqMap.Add(arr[i], 1);
      }
    }
 
    // Printing the freqMap
    foreach(KeyValuePair<int, int> entry in freqMap)
    {
      Console.WriteLine(entry.Key + " " + entry.Value);
    }
  }
 
  public static void Main(String []args) 
  {
    int []arr = {10, 20, 20, 10, 10, 20, 5, 20};
    int size = arr.Length;
    frequencyNumber(arr,size);
  }
}
// This code is contributed by Taranpreet
 
  

Javascript

   <script>
// Javascript program to count frequencies of
// integers in array using Hashmap
 
function frequencyNumber(arr,size)
{
    // Creating a HashMap containing integer
        // as a key and occurrences as a value
        let freqMap
            = new Map();
  
        for (let i=0;i<size;i++) {
            if (freqMap.has(arr[i])) {
  
                // If number is present in freqMap,
                // incrementing it's count by 1
                freqMap.set(arr[i], freqMap.get(arr[i]) + 1);
            }
            else {
  
                // If integer is not present in freqMap,
                // putting this integer to freqMap with 1 as it's value
                freqMap.set(arr[i], 1);
            }
        }
  
        // Printing the freqMap
        for (let [key, value] of freqMap.entries()) {
            document.write(key + " " + value+"<br>");
        }
}
 
// Driver Code
let arr=[10, 20, 20, 10, 10, 20, 5, 20];
let size = arr.length;
frequencyNumber(arr,size);
 
// This code is contributed by patel2127
</script>
 
  

Output

5 1 20 4 10 3

Complexity Analysis:

Time Complexity: O(n) since using a single loop to track frequency
Auxiliary Space: O(n) for hashmap.

Another Efficient Solution (Space optimization): we can find frequency of array elements using Binary search function . First we will sort the array for binary search . Our frequency of element will be ‘(last occ – first occ)+1’ of a element in a array .

Below is the implementation of the above approach:

C++

   // C++ implementation of the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
//Function to find frequency of elements in the array
void countFreq(int arr[], int n)
{   
    sort(arr,arr+n);//sort array for binary search
    
    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;
      i=last_index;
       
      int fre=last_index-first_index+1;//finding frequency
      cout << arr[i] <<" "<<fre <<endl;//printing frequency
    } 
}
 
// Drive code
int main()
{   
    int arr[] = { 10, 20, 20, 10, 10, 20, 5, 20 };
    int n = sizeof(arr) / sizeof(arr[0]);
   
    // Function call
    countFreq(arr, n);
    return 0;
     
}
 
// This Code is contributed by nikhilsainiofficial546
 
  

Java

   // Java program to count frequencies of
// integers in array using Hashmap
import java.io.*;
import java.util.*;
class OccurenceOfNumberInArray {
    public static void countFreq(int[] arr, int n) {
    Arrays.sort(arr); //sort array for binary search
 
    for (int i = 0; i < n; i++) {
        //index of first and last occ of arr[i]
        int first_index = Arrays.binarySearch(arr, arr[i]);
        int last_index = Arrays.binarySearch(arr, arr[i]);
 
        while (first_index > 0 && arr[first_index - 1] == arr[i]) {
            first_index--;
        }
 
        while (last_index < n - 1 && arr[last_index + 1] == arr[i]) {
            last_index++;
        }
 
        i = last_index;
 
        int fre = last_index - first_index + 1;//finding frequency
        System.out.println(arr[i] + " " + fre);//printing frequency
    }
}
    // Driver Code
    public static void main(String[] args)
    {
        int arr[] = {10, 20, 20, 10, 10, 20, 5, 20};
        int size = arr.length;
        countFreq(arr,size);
    }
}
 
  

Python3

   from bisect import bisect_left, bisect_right
 
# Function to find frequency of elements in the array
def countFreq(arr, n):
    arr.sort()  # sort array for binary search
 
    i = 0
    while i < n:
        # index of first and last occ of arr[i]
        first_index = bisect_left(arr, arr[i])
        last_index = bisect_right(arr, arr[i]) - 1
        i = last_index + 1
 
        fre = last_index - first_index + 1  # finding frequency
        print(arr[i - 1], fre)  # printing frequency
 
# Driver code
arr = [10, 20, 20, 10, 10, 20, 5, 20]
n = len(arr)
countFreq(arr, n)
 
  

C#

   using System;
 
public class GFG {
 
    // Function to find frequency of elements in the array
    public static void countFreq(int[] arr, int n) {
        Array.Sort(arr); // sort array for binary search
 
        for (int i = 0; i < n; i++) {
            // index of first and last occurrence of arr[i]
            int first_index = Array.IndexOf(arr, arr[i]);
            int last_index = Array.LastIndexOf(arr, arr[i]);
 
            int fre = last_index - first_index + 1; // finding frequency
            Console.WriteLine(arr[i] + " " + fre); // printing frequency
            i = last_index;
        }
    }
 
    // Driver code
    static public void Main () {
        int[] arr = { 10, 20, 20, 10, 10, 20, 5, 20 };
        int n = arr.Length;
 
        // Function call
        countFreq(arr, n);
    }
}
 
  

Javascript

   // Javascript implementation of the above approach
 
//Function to find frequency of elements in the array
function countFreq(arr,n) {
    arr.sort((a, b) => a - b); //sort array for binary search
    let i = 0;
    while (i < n) {
        //index of first and last occ of arr[i]
        const first_index = arr.indexOf(arr[i]);
        const last_index = arr.lastIndexOf(arr[i]);
        i = last_index;
 
        const fre = last_index - first_index + 1; //finding frequency
        console.log(arr[i], fre); //printing frequency
        i++;
    }
}
 
// Driver code
const arr = [ 10, 20, 20, 10, 10, 20, 5, 20 ];
countFreq(arr,arr.length);
 
  

Output

5 1 10 3 20 4

Time Complexity: O(n*log₂n) , where O(log₂n) time for binary search function .
Auxiliary Space: O(1)

JavaScript - Counting Frequencies of Array Elements

kartik

Improve

Article Tags :

Practice Tags :

Similar Reads

JavaScript - Counting Frequencies of Array Elements

Here are the various approaches to count the frequencies of array elements in JavaScript. Using an Object (Simple and Efficient)This is the most common approach for counting frequency in an array. Each array element becomes a key in the object, and its value is incremented as the element appears. [G

Frequency of an element in an array

Given an array, a[], and an element x, find a number of occurrences of x in a[]. Examples: Input : a[] = {0, 5, 5, 5, 4} x = 5Output : 3Input : a[] = {1, 2, 3} x = 4Output : 0 Unsorted ArrayThe idea is simple, we initialize count as 0. We traverse the array in a linear fashion. For every element tha

Count frequency of digit K in given Array

Given an array arr[] of integers of size N and a single digit integer K. The task is to find the total count of occurrences of the digit K in the array Examples: Input: arr[] = {15, 66, 26, 91}, K = 6Output: 3Explanation: Occurrences of 6 in each array elements are: 0, 2, 1, 0 respectively.Therefore

Count Distinct ( Unique ) elements in an array

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: 3Explanation: 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 ru

Range Queries for Frequencies of array elements

Given an array of n non-negative integers. The task is to find frequency of a particular element in the arbitrary range of array[]. The range is given as positions (not 0 based indexes) in array. There can be multiple queries of given type. Examples: Input : arr[] = {2, 8, 6, 9, 8, 6, 8, 2, 11}; lef

Count of Subsequences with distinct elements

Given an array arr[] (1<=a[i]<=1e9) containing N (1<=N<=1e5) elements, the task is to find the total number of subsequences such that all elements in that subsequences are distinct. Since the answer can be very large print and modulo 1e9+7. Examples: Input: arr[] = [1, 1, 2, 2]Output: 8E

Count distinct elements in an array in Python

Given an unsorted array, count all distinct elements in it. Examples: Input : arr[] = {10, 20, 20, 10, 30, 10} Output : 3 Input : arr[] = {10, 20, 20, 10, 20} Output : 2 We have existing solution for this article. We can solve this problem in Python3 using Counter method. Approach#1: Using Set() Thi

Count Subsequences with ordered integers in Array

Given an array nums[] of N positive integers, the task is to find the number of subsequences that can be created from the array where each subsequence contains all integers from 1 to its size in any order. If two subsequences have different chosen indices, then they are considered different. Example

Count of smaller or equal elements in sorted array

Given a sorted array of size n. Find a number of elements that are less than or equal to a given element. Examples: Input : arr[] = {1, 2, 4, 5, 8, 10} key = 9 Output : 5 Elements less than or equal to 9 are 1, 2, 4, 5, 8 therefore result will be 5. Input : arr[] = {1, 2, 2, 2, 5, 7, 9} key = 2 Outp

Count pairs formed by distinct element sub-arrays

Given an array, count number of pairs that can be formed from all possible contiguous sub-arrays containing distinct numbers. The array contains positive numbers between 0 to n-1 where n is the size of the array. Examples: Input: [1, 4, 2, 4, 3, 2] Output: 8 The subarrays with distinct elements are