Open In App

Range Queries for Frequencies of array elements

Improve
Improve
Like Article
Like
Save
Share
Report

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};
         left = 2, right = 8, element = 8
         left = 2, right = 5, element = 6      
Output : 3
         1
The element 8 appears 3 times in arr[left-1..right-1]
The element 6 appears 1 time in arr[left-1..right-1]

Naive approach: is to traverse from left to right and update count variable whenever we find the element. 

Below is the code of Naive approach:- 

C++




// C++ program to find total count of an element
// in a range
#include<bits/stdc++.h>
using namespace std;
  
// Returns count of element in arr[left-1..right-1]
int findFrequency(int arr[], int n, int left,
                         int right, int element)
{
    int count = 0;
    for (int i=left-1; i<=right; ++i)
        if (arr[i] == element)
            ++count;
    return count;
}
  
// Driver Code
int main()
{
    int arr[] = {2, 8, 6, 9, 8, 6, 8, 2, 11};
    int n = sizeof(arr) / sizeof(arr[0]);
  
    // Print frequency of 2 from position 1 to 6
    cout << "Frequency of 2 from 1 to 6 = "
         << findFrequency(arr, n, 1, 6, 2) << endl;
  
    // Print frequency of 8 from position 4 to 9
    cout << "Frequency of 8 from 4 to 9 = "
         << findFrequency(arr, n, 4, 9, 8);
  
    return 0;
}


Java




// JAVA Code to find total count of an element
// in a range
  
class GFG {
      
    // Returns count of element in arr[left-1..right-1]
    public static int findFrequency(int arr[], int n, 
                                int left, int right,
                                      int element)
    {
        int count = 0;
        for (int i = left - 1; i < right; ++i)
            if (arr[i] == element)
                ++count;
        return count;
    }
      
    /* Driver program to test above function */
    public static void main(String[] args) 
    {
        int arr[] = {2, 8, 6, 9, 8, 6, 8, 2, 11};
        int n = arr.length;
       
        // Print frequency of 2 from position 1 to 6
        System.out.println("Frequency of 2 from 1 to 6 = " +
             findFrequency(arr, n, 1, 6, 2));
       
        // Print frequency of 8 from position 4 to 9
        System.out.println("Frequency of 8 from 4 to 9 = " +
             findFrequency(arr, n, 4, 9, 8));
          
    }
  
// This code is contributed by Arnav Kr. Mandal.


Python3




# Python program to find total  
# count of an element in a range
  
# Returns count of element
# in arr[left-1..right-1]
def findFrequency(arr, n, left, right, element):
  
    count = 0
    for i in range(left - 1, right):
        if (arr[i] == element):
            count += 1
    return count
  
  
# Driver Code
arr = [2, 8, 6, 9, 8, 6, 8, 2, 11]
n = len(arr)
  
# Print frequency of 2 from position 1 to 6
print("Frequency of 2 from 1 to 6 = ",
        findFrequency(arr, n, 1, 6, 2))
  
# Print frequency of 8 from position 4 to 9
print("Frequency of 8 from 4 to 9 = ",
        findFrequency(arr, n, 4, 9, 8))
          
      
# This code is contributed by Anant Agarwal.


C#




// C# Code to find total count 
// of an element in a range
using System;
  
class GFG {
      
    // Returns count of element 
    // in arr[left-1..right-1]
    public static int findFrequency(int []arr, int n, 
                                    int left, int right,
                                    int element)
    {
        int count = 0;
        for (int i = left - 1; i < right; ++i)
            if (arr[i] == element)
                ++count;
        return count;
    }
      
    // Driver Code
    public static void Main() 
    {
        int []arr = {2, 8, 6, 9, 8, 6, 8, 2, 11};
        int n = arr.Length;
      
        // Print frequency of 2 
        // from position 1 to 6
        Console.WriteLine("Frequency of 2 from 1 to 6 = " +
                            findFrequency(arr, n, 1, 6, 2));
      
        // Print frequency of 8 
        // from position 4 to 9
        Console.Write("Frequency of 8 from 4 to 9 = " +
                       findFrequency(arr, n, 4, 9, 8));
          
    }
  
// This code is contributed by Nitin Mittal.


PHP




<?php
// PHP program to find total count of 
// an element in a range
  
// Returns count of element in 
// arr[left-1..right-1]
function findFrequency(&$arr, $n, $left,
                        $right, $element)
{
    $count = 0;
    for ($i = $left - 1; $i <= $right; ++$i)
        if ($arr[$i] == $element)
            ++$count;
    return $count;
}
  
// Driver Code
$arr = array(2, 8, 6, 9, 8, 6, 8, 2, 11);
$n = sizeof($arr);
  
// Print frequency of 2 from position 1 to 6
echo "Frequency of 2 from 1 to 6 = "
      findFrequency($arr, $n, 1, 6, 2) ."\n";
  
// Print frequency of 8 from position 4 to 9
echo "Frequency of 8 from 4 to 9 = "
      findFrequency($arr, $n, 4, 9, 8);
  
// This code is contributed by ita_c
?>


Javascript




<script>
  
// Javascript Code to find total count of an element
// in a range
      
    // Returns count of element in arr[left-1..right-1]
    function findFrequency(arr,n,left,right,element)
    {
        let count = 0;
        for (let i = left - 1; i < right; ++i)
            if (arr[i] == element)
                ++count;
        return count;
    }
      
    /* Driver program to test above function */
    let arr=[2, 8, 6, 9, 8, 6, 8, 2, 11];
    let n = arr.length;
      
    // Print frequency of 2 from position 1 to 6
    document.write("Frequency of 2 from 1 to 6 = " +
             findFrequency(arr, n, 1, 6, 2)+"<br>");
      
    // Print frequency of 8 from position 4 to 9
    document.write("Frequency of 8 from 4 to 9 = " +
             findFrequency(arr, n, 4, 9, 8));
      
    // This code is contributed by rag2127
      
</script>


Output

Frequency of 2 from 1 to 6 = 1
Frequency of 8 from 4 to 9 = 2

Time complexity of this approach is O(right – left + 1) or O(n) 
Auxiliary space: O(1)

An Efficient approach is to use hashing. In C++, we can use unordered_map

  • At first, we will store the position in map[] of every distinct element as a vector like that 
  int arr[] = {2, 8, 6, 9, 8, 6, 8, 2, 11};
  map[2] = {1, 8}
  map[8] = {2, 5, 7}
  map[6] = {3, 6} 
  ans so on...
  • As we can see that elements in map[] are already in sorted order (Because we inserted elements from left to right), the answer boils down to find the total count in that hash map[] using binary search like method. 
     
  • In C++ we can use lower_bound which will returns an iterator pointing to the first element in the range [first, last] which has a value not less than ‘left’. and upper_bound returns an iterator pointing to the first element in the range [first,last) which has a value greater than ‘right’. 
     
  • After that we just need to subtract the upper_bound() and lower_bound() result to get the final answer. For example, suppose if we want to find the total count of 8 in the range from [1 to 6], then the map[8] of lower_bound() function will return the result 0 (pointing to 2) and upper_bound() will return 2 (pointing to 7), so we need to subtract the both the result like 2 – 0 = 2 . 
     

Below is the code of above approach 

C++




// C++ program to find total count of an element
#include<bits/stdc++.h>
using namespace std;
  
unordered_map< int, vector<int> > store;
  
// Returns frequency of element in arr[left-1..right-1]
int findFrequency(int arr[], int n, int left,
                      int right, int element)
{
    // Find the position of first occurrence of element
    int a = lower_bound(store[element].begin(),
                        store[element].end(),
                        left)
            - store[element].begin();
  
    // Find the position of last occurrence of element
    int b = upper_bound(store[element].begin(),
                        store[element].end(),
                        right)
            - store[element].begin();
  
    return b-a;
}
  
// Driver code
int main()
{
    int arr[] = {2, 8, 6, 9, 8, 6, 8, 2, 11};
    int n = sizeof(arr) / sizeof(arr[0]);
  
    // Storing the indexes of an element in the map
    for (int i=0; i<n; ++i)
        store[arr[i]].push_back(i+1); //starting index from 1
  
    // Print frequency of 2 from position 1 to 6
    cout << "Frequency of 2 from 1 to 6 = "
         << findFrequency(arr, n, 1, 6, 2) <<endl;
  
    // Print frequency of 8 from position 4 to 9
    cout << "Frequency of 8 from 4 to 9 = "
         << findFrequency(arr, n, 4, 9, 8);
  
    return 0;
}


Java




// Java program to find total count of an element
import java.util.*;
  
public class GFG {
  
  static HashMap<Integer, ArrayList<Integer> > store;
  
  static int lower_bound(ArrayList<Integer> a, int low,
                         int high, int key)
  {
    if (low > high) {
      return low;
    }
    int mid = low + (high - low) / 2;
    if (key <= a.get(mid)) {
  
      return lower_bound(a, low, mid - 1, key);
    }
    return lower_bound(a, mid + 1, high, key);
  }
  
  static int upper_bound(ArrayList<Integer> a, int low,
                         int high, int key)
  {
    if (low > high || low == a.size())
      return low;
    int mid = low + (high - low) / 2;
    if (key >= a.get(mid)) {
      return upper_bound(a, mid + 1, high, key);
    }
    return upper_bound(a, low, mid - 1, key);
  }
  
  // Returns frequency of element in arr[left-1..right-1]
  static int findFrequency(int arr[], int n, int left,
                           int right, int element)
  {
    // Find the position of first occurrence of element
    int a
      = lower_bound(store.get(element), 0,
                    store.get(element).size(), left);
  
    // Find the position of last occurrence of element
    int b
      = upper_bound(store.get(element), 0,
                    store.get(element).size(), right);
  
    return b - a;
  }
  
  // Driver code
  public static void main(String[] args)
  {
    int arr[] = { 2, 8, 6, 9, 8, 6, 8, 2, 11 };
    int n = arr.length;
  
    // Storing the indexes of an element in the map
    store = new HashMap<>();
    for (int i = 0; i < n; ++i) {
      if (!store.containsKey(arr[i]))
        store.put(arr[i], new ArrayList<>());
      store.get(arr[i]).add(
        i + 1); // starting index from 1
    }
  
    // Print frequency of 2 from position 1 to 6
    System.out.println(
      "Frequency of 2 from 1 to 6 = "
      + findFrequency(arr, n, 1, 6, 2));
  
    // Print frequency of 8 from position 4 to 9
    System.out.println(
      "Frequency of 8 from 4 to 9 = "
      + findFrequency(arr, n, 4, 9, 8));
  }
}
  
// This code is contributed by Karandeep1234


Python3




# Python3 program to find total count of an element
from collections import defaultdict as dict
from bisect import bisect_left as lower_bound
from bisect import bisect_right as upper_bound
  
store = dict(list)
  
# Returns frequency of element 
# in arr[left-1..right-1]
def findFrequency(arr, n, left, right, element):
      
    # Find the position of 
    # first occurrence of element
    a = lower_bound(store[element], left)
  
    # Find the position of
    # last occurrence of element
    b = upper_bound(store[element], right)
  
    return b - a
  
# Driver code
arr = [2, 8, 6, 9, 8, 6, 8, 2, 11]
n = len(arr)
  
# Storing the indexes of
# an element in the map
for i in range(n):
    store[arr[i]].append(i + 1)
  
# Print frequency of 2 from position 1 to 6
print("Frequency of 2 from 1 to 6 = "
       findFrequency(arr, n, 1, 6, 2))
  
# Print frequency of 8 from position 4 to 9
print("Frequency of 8 from 4 to 9 = ",
       findFrequency(arr, n, 4, 9, 8))
  
# This code is contributed by Mohit Kumar


C#




// C# program to find total count of an element
  
using System;
using System.Collections;
using System.Collections.Generic;
  
public class GFG {
  
    static Dictionary<int, List<int> > store;
  
    static int lower_bound(List<int> a, int low, int high,
                           int key)
    {
        if (low > high) {
            return low;
        }
        int mid = low + (high - low) / 2;
        if (key <= a[mid]) {
  
            return lower_bound(a, low, mid - 1, key);
        }
        return lower_bound(a, mid + 1, high, key);
    }
  
    static int upper_bound(List<int> a, int low, int high,
                           int key)
    {
        if (low > high || low == a.Count)
            return low;
        int mid = low + (high - low) / 2;
        if (key >= a[mid]) {
            return upper_bound(a, mid + 1, high, key);
        }
        return upper_bound(a, low, mid - 1, key);
    }
  
    // Returns frequency of element in arr[left-1..right-1]
    static int findFrequency(int[] arr, int n, int left,
                             int right, int element)
    {
        // Find the position of first occurrence of element
        int a = lower_bound(store[element], 0,
                            store[element].Count, left);
  
        // Find the position of last occurrence of element
        int b = upper_bound(store[element], 0,
                            store[element].Count, right);
  
        return b - a;
    }
  
    // Driver code
    public static void Main(string[] args)
    {
        int[] arr = { 2, 8, 6, 9, 8, 6, 8, 2, 11 };
        int n = arr.Length;
  
        // Storing the indexes of an element in the map
        store = new Dictionary<int, List<int> >();
        for (int i = 0; i < n; ++i) {
            if (!store.ContainsKey(arr[i]))
                store.Add(arr[i], new List<int>());
            store[arr[i]].Add(i
                              + 1); // starting index from 1
        }
  
        // Print frequency of 2 from position 1 to 6
        Console.WriteLine("Frequency of 2 from 1 to 6 = "
                          + findFrequency(arr, n, 1, 6, 2));
  
        // Print frequency of 8 from position 4 to 9
        Console.WriteLine("Frequency of 8 from 4 to 9 = "
                          + findFrequency(arr, n, 4, 9, 8));
    }
}
  
// This code is contributed by Karandeep1234


Javascript




   var store = null;
  function lower_bound(a, low, high, key)
  {
      if (low > high)
      {
          return low;
      }
      var mid = low + parseInt((high - low) / 2);
      if (key <= a[mid])
      {
          return lower_bound(a, low, mid - 1, key);
      }
      return lower_bound(a, mid + 1, high, key);
  }
  function upper_bound(a, low, high, key)
  {
      if (low > high || low == a.length)
      {
          return low;
      }
      var mid = low + parseInt((high - low) / 2);
      if (key >= a[mid])
      {
          return upper_bound(a, mid + 1, high, key);
      }
      return upper_bound(a, low, mid - 1, key);
  }
    
  // Returns frequency of element in arr[left-1..right-1]
  function findFrequency(arr, n, left, right, element)
  {
    
      // Find the position of first occurrence of element
      var a = lower_bound(store.get(element), 0, store.get(element).length, left);
        
      // Find the position of last occurrence of element
      var b = upper_bound(store.get(element), 0, store.get(element).length, right);
      return b - a;
  }
  // Driver code
    
      var arr = [2, 8, 6, 9, 8, 6, 8, 2, 11];
      var n = arr.length;
        
      // Storing the indexes of an element in the map
      store = new Map();
      var i=0;
      for (i; i < n; ++i)
      {
          if (!store.has(arr[i]))
          {
              store.set(arr[i],new Array());
          }
          (store.get(arr[i]).push(i + 1) > 0);
      }
        
      // Print frequency of 2 from position 1 to 6
      console.log("Frequency of 2 from 1 to 6 = " + findFrequency(arr, n, 1, 6, 2));
        
      // Print frequency of 8 from position 4 to 9
      console.log("Frequency of 8 from 4 to 9 = " + findFrequency(arr, n, 4, 9, 8));
  
// This code is contributed by sourabhdalal0001.


Output

Frequency of 2 from 1 to 6 = 1
Frequency of 8 from 4 to 9 = 2

This approach will be beneficial if we have a large number of queries of an arbitrary range asking the total frequency of particular element.
Time complexity: O(log N) for single query.
Auxiliary Space: O(N)

 



Last Updated : 12 Sep, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads