Range Frequency Queries - Practice Coding Problems

Range Frequency Queries - Problem

Array Hash Table Binary Search Design Segment Tree Medium

Design a Smart Frequency Counter Data Structure

Imagine you're building a data analysis tool that needs to quickly answer questions like: "How many times does the value 5 appear between positions 2 and 8 in this dataset?"

Your task is to implement the RangeFreqQuery class that can efficiently handle multiple frequency queries on subarrays:

Constructor: RangeFreqQuery(int[] arr) - Initialize with a 0-indexed integer array
Query Method: int query(int left, int right, int value) - Return how many times value appears in the subarray arr[left...right] (inclusive)

Example: If arr = [12, 33, 4, 56, 22, 2, 34, 33, 22, 12, 34, 56]
• query(1, 2, 4) returns 1 (value 4 appears once in subarray [33, 4])
• query(0, 2, 33) returns 1 (value 33 appears once in subarray [12, 33, 4])
• query(1, 3, 33) returns 1 (value 33 appears once in subarray [33, 4, 56])

Input & Output

example_1.py — Basic Usage

$ Input: arr = [12, 33, 4, 56, 22, 2, 34, 33, 22, 12, 34, 56] queries = [ query(1, 2, 4), query(0, 2, 33) ]

› Output: [1, 1]

💡 Note: First query: In subarray [33, 4] (indices 1-2), value 4 appears 1 time. Second query: In subarray [12, 33, 4] (indices 0-2), value 33 appears 1 time.

example_2.py — Multiple Occurrences

$ Input: arr = [1, 2, 2, 1, 2, 3] queries = [ query(0, 5, 2), query(1, 4, 2), query(0, 1, 1) ]

› Output: [3, 2, 1]

💡 Note: Value 2 appears 3 times in entire array [0,5], 2 times in range [1,4], and value 1 appears 1 time in range [0,1].

example_3.py — Edge Cases

$ Input: arr = [5] queries = [ query(0, 0, 5), query(0, 0, 1) ]

› Output: [1, 0]

💡 Note: Single element array: value 5 found once at index 0, value 1 not found (returns 0).

Constraints

1 ≤ arr.length ≤ 10⁵
-10⁴ ≤ arr[i] ≤ 10⁴
1 ≤ number of queries ≤ 10⁴
0 ≤ left ≤ right < arr.length
Time limit: 2 seconds per test case

Visualization

Tap to expand

Understanding the Visualization

Build the Catalog

Create index cards for each book type, listing all shelf positions where they appear

Smart Lookup

When asked about a range, grab the card for that book type

Binary Search Magic

Use the sorted positions to quickly count how many fall within the requested range

Key Takeaway

🎯 Key Insight: Instead of repeatedly scanning data, preprocess it once into a searchable format. The hash map + binary search combination turns O(n) queries into O(log n) lookups!

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 35 f Meta 28

The optimal solution uses preprocessing with hash maps and binary search. During initialization, build a hash map where each unique value maps to a sorted list of its positions. For queries, use binary search to quickly count positions within the given range. This achieves O(log n) query time after O(n) preprocessing, making it highly efficient for multiple queries.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Scan)	O(n) per query	O(1)	For each query, iterate through the range and count occurrences
Hash Map + Binary Search (Optimal)	O(log n) per query, O(n) preprocessing	O(n)	Preprocess array into hash map of positions, then use binary search for range queries

Brute Force (Linear Scan) — Algorithm Steps

Store the input array in the constructor
For each query(left, right, value), initialize counter to 0
Loop from index left to right (inclusive)
If arr[i] equals value, increment counter
Return the counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Query Setup

Receive query(1, 2, 4) - looking for value 4 in range [1,2]

Scan Range

Check arr[1]=33 (not 4), arr[2]=4 (match!), count=1

Return Result

Return count=1 as the frequency of 4 in the specified range

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.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;
}

void rangeFreqQueryFree(RangeFreqQuery* obj) {
    free(obj);
}

// Example usage
int main() {
    int arr[] = {12, 33, 4, 56, 22, 2, 34, 33, 22, 12, 34, 56};
    int size = sizeof(arr) / sizeof(arr[0]);
    RangeFreqQuery* rfq = rangeFreqQueryCreate(arr, size);
    printf("%d\n", rangeFreqQueryQuery(rfq, 1, 2, 4));   // Output: 1
    printf("%d\n", rangeFreqQueryQuery(rfq, 0, 2, 33));  // Output: 1
    rangeFreqQueryFree(rfq);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n) per query

Each query scans up to n elements in the worst case

✓ Linear Growth

Space Complexity

O(1)

Only stores the original array, no additional data structures

✓ Linear Space

68.9K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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 (Linear Scan) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler