Range Queries for Frequencies of array elements

Last Updated : 12 Sep, 2023

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)

Shubham Bansal

Improve

Range sum queries without updates

Count Primes in Ranges

Range Queries for Frequencies of array elements

C++

Java

Python3

C#

PHP

Javascript

C++

Java

Python3

C#

Javascript

Please Login to comment...

Similar Reads

What kind of Experience do you want to share?