Range Frequency Queries

Range Frequency Queries - Problem

Array Hash Table Binary Search Design Segment Tree Medium

Design a data structure to find the frequency of a given value in a given subarray.

The frequency of a value in a subarray is the number of occurrences of that value in the subarray.

Implement the RangeFreqQuery class:

RangeFreqQuery(int[] arr) Constructs an instance of the class with the given 0-indexed integer array arr.
int query(int left, int right, int value) Returns the frequency of value in the subarray arr[left...right].

A subarray is a contiguous sequence of elements within an array. arr[left...right] denotes the subarray that contains the elements of arr between indices left and right (inclusive).

Input & Output

Example 1 — Basic Range Query

$ Input: arr = [1,2,2,3,1], operations = [[0,4,1],[1,3,2]]

› Output: [2,2]

💡 Note: For query [0,4,1]: value 1 appears at indices 0 and 4, both in range → count = 2. For query [1,3,2]: value 2 appears at indices 1 and 2, both in range → count = 2.

Example 2 — Value Not in Range

$ Input: arr = [1,1,1,1], operations = [[1,2,2]]

› Output: [0]

💡 Note: Query [1,2,2]: looking for value 2 in range [1,2], but value 2 doesn't exist in the array → count = 0.

Example 3 — Single Element Range

$ Input: arr = [5,3,5,1,5], operations = [[0,0,5],[2,2,5]]

› Output: [1,1]

💡 Note: Query [0,0,5]: range contains only index 0 with value 5 → count = 1. Query [2,2,5]: range contains only index 2 with value 5 → count = 1.

Constraints

1 ≤ arr.length ≤ 10⁵
1 ≤ value ≤ 10⁴
0 ≤ left ≤ right < arr.length
At most 10⁵ calls to query

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is to preprocess the array by grouping indices by their values in a hash map. For each query, use binary search on the sorted index list to count occurrences within the given range. Best approach uses Hash Map with Binary Search for O(log n) query time after O(n) preprocessing. Time: O(log n) per query, Space: O(n).

Common Approaches

✓ Brute Force

⏱️ Time: O(n) Space: O(1)

Store the array and for each query, loop through the specified range counting how many times the target value appears. This is straightforward but inefficient for multiple queries.

Hash Map with Index Lists

⏱️ Time: O(log n) Space: O(n)

Preprocess the array by creating a hash map where each value maps to a sorted list of its indices. For queries, use binary search on the index list to count occurrences in the given range.

Brute Force — Algorithm Steps

Store the input array
For each query, loop from left to right index
Count occurrences of the target value in that range

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Array

Keep the original array in memory

Scan Range

For each query, iterate through [left, right] counting target value

Return Count

Return the frequency count for that range

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int* arr;
    int size;
} RangeFreqQuery;

RangeFreqQuery* rangeFreqQueryCreate(int* arr, int arrSize) {
    RangeFreqQuery* obj = (RangeFreqQuery*)malloc(sizeof(RangeFreqQuery));
    obj->arr = arr;
    obj->size = arrSize;
    return obj;
}

int rangeFreqQueryQuery(RangeFreqQuery* obj, int left, int right, int value) {
    int count = 0;
    for (int i = left; i <= right; i++) {
        if (obj->arr[i] == value) {
            count++;
        }
    }
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int arr[1000];
    int arrSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token) {
        arr[arrSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    // Parse operations
    fgets(line, sizeof(line), stdin);
    int operations[100][3];
    int opCount = 0;
    
    char* ptr = line;
    while (*ptr) {
        if (*ptr == '[') {
            ptr++;
            operations[opCount][0] = atoi(ptr);
            while (*ptr != ',') ptr++;
            ptr++;
            operations[opCount][1] = atoi(ptr);
            while (*ptr != ',') ptr++;
            ptr++;
            operations[opCount][2] = atoi(ptr);
            opCount++;
            while (*ptr != ']') ptr++;
        }
        ptr++;
    }
    
    RangeFreqQuery* rfq = rangeFreqQueryCreate(arr, arrSize);
    
    printf("[");
    for (int i = 0; i < opCount; i++) {
        int result = rangeFreqQueryQuery(rfq, operations[i][0], operations[i][1], operations[i][2]);
        printf("%d", result);
        if (i < opCount - 1) printf(",");
    }
    printf("]\n");
    
    free(rfq);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each query requires iterating through up to n elements in the range

⚡ Linearithmic

Space Complexity

O(1)

Only storing the original array, no additional data structures

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler