# 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}; 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; ` `} ` |

*chevron_right*

*filter_none*

## 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. ` |

*chevron_right*

*filter_none*

## 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. ` |

*chevron_right*

*filter_none*

## 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. ` |

*chevron_right*

*filter_none*

## 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 ` `?> ` |

*chevron_right*

*filter_none*

**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; ` `} ` |

*chevron_right*

*filter_none*

## 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` `) ` ` ` `# Prfrequency of 2 from position 1 to 6 ` `print` `(` `"Frequency of 2 from 1 to 6 = "` `, ` ` ` `findFrequency(arr, n, ` `1` `, ` `6` `, ` `2` `)) ` ` ` `# Prfrequency 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 ` |

*chevron_right*

*filter_none*

**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.

This article is contributed by Shubham Bansal. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

## Recommended Posts:

- Find array elements with frequencies in range [l , r]
- Queries for GCD of all numbers of an array except elements in a given range
- Array range queries for elements with frequency same as value
- Queries for counts of array elements with values in given range
- Array range queries to find the number of perfect square elements with updates
- Queries for elements having values within the range A to B in the given index range using Segment Tree
- Range Queries to count elements lying in a given Range : MO's Algorithm
- Array range queries over range queries
- Elements of first array that have more frequencies
- Find the XOR of the elements in the given range [L, R] with the value K for a given set of queries
- Array elements with prime frequencies
- Counting frequencies of array elements
- Queries for elements having values within the range A to B using MO's Algorithm
- Find the frequencies of all duplicates elements in the array
- Queries for count of even digit sum elements in given range using MO's Algorithm
- Count of elements which are power of 2 in a given range subarray for Q queries
- Sum of elements in an array with frequencies greater than or equal to that element
- Queries for the count of even digit sum elements in the given range using Segment Tree.
- Queries to check whether all the elements in the given range occurs even number of times
- Queries for elements greater than K in the given index range using Segment Tree