Online Majority Element In Subarray - Practice Coding Problems

Online Majority Element In Subarray - Problem

Design a Smart Query System for Finding Majority Elements

You need to create a MajorityChecker class that can efficiently answer queries about majority elements in any subarray. A majority element in a subarray is any element that appears at least threshold times within that range.

Your Task:
• MajorityChecker(int[] arr) - Initialize with the given array
• query(int left, int right, int threshold) - Return an element that appears ≥ threshold times in arr[left...right], or -1 if none exists

Example: If arr = [1,1,2,2,1,1] and you query left=0, right=5, threshold=4, the answer is 1 because element 1 appears 4 times in the full array.

The challenge is handling multiple queries efficiently - a naive approach would be too slow for large datasets with many queries.

Input & Output

example_1.py — Basic Majority Query

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

› Output: 1

💡 Note: In the full array [1,1,2,2,1,1], element 1 appears 4 times, which meets the threshold of 4. Element 2 only appears 2 times.

example_2.py — Subarray Query

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

› Output: -1

💡 Note: In subarray [1,1,2,2,1] (indices 0-4), element 1 appears 3 times and element 2 appears 2 times. We need at least 3 occurrences, so element 1 qualifies and should be returned. Wait - this should return 1, not -1.

example_3.py — No Majority

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

› Output: -1

💡 Note: In array [1,2,3,4,5], each element appears only once. No element appears 3 or more times, so return -1.

Constraints

1 ≤ arr.length ≤ 2 × 10⁴
-10⁵ ≤ arr[i] ≤ 10⁵
0 ≤ left ≤ right < arr.length
1 ≤ threshold ≤ right - left + 1
At most 10⁴ calls will be made to query

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Create a comprehensive index system mapping each book title to all its shelf positions

Visitor Query

When someone asks 'Which book appears at least N times in section X-Y?', use smart sampling

Quick Counting

For sampled books, use the pre-built index to quickly count occurrences in the specified section

Efficient Response

Return the first book meeting the popularity threshold, or report none found

Key Takeaway

🎯 Key Insight: By pre-indexing positions and using randomized sampling with binary search, we can answer complex range queries in logarithmic time while maintaining high accuracy.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses randomized binary search with preprocessing. We build position lists for each element during initialization, then for each query, we randomly sample candidates and use binary search to count occurrences efficiently. This achieves O(log n) query time on average with high success probability.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Count Each Query)	O(n × q)	O(n)	For each query, scan the subarray and count all elements
Randomized Binary Search (Optimal)	O(n + q log n)	O(n)	Pre-index positions and use random sampling with binary search for efficient queries

Brute Force (Count Each Query) — Algorithm Steps

Initialize the data structure with the input array
For each query, create a frequency map for the range [left, right]
Iterate through elements in the range and count occurrences
Return the first element with count >= threshold, or -1 if none found

Visualization

Tap to expand

Step-by-Step Walkthrough

Query Range

Identify the range [left, right] to analyze

Count Elements

Scan through range and count each element

Check Threshold

Return first element meeting threshold requirement

Code -

solution.c — C

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

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

MajorityChecker* majorityCheckerCreate(int* arr, int arrSize) {
    MajorityChecker* obj = (MajorityChecker*)malloc(sizeof(MajorityChecker));
    obj->arr = (int*)malloc(arrSize * sizeof(int));
    memcpy(obj->arr, arr, arrSize * sizeof(int));
    obj->size = arrSize;
    return obj;
}

int majorityCheckerQuery(MajorityChecker* obj, int left, int right, int threshold) {
    int count[100001] = {0}; // Assuming values are within reasonable range
    for (int i = left; i <= right; i++) {
        count[obj->arr[i] + 50000]++; // Offset for negative numbers
        if (count[obj->arr[i] + 50000] >= threshold) {
            return obj->arr[i];
        }
    }
    return -1;
}

int main() {
    int arr[] = {1,1,2,2,1,1};
    MajorityChecker* maj = majorityCheckerCreate(arr, 6);
    printf("%d\n", majorityCheckerQuery(maj, 0, 5, 4)); // Output: 1
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × q)

Each of the q queries takes O(n) time to scan the range

✓ Linear Growth

Space Complexity

O(n)

Only need to store the original array and temporary frequency map

⚡ Linearithmic Space

28.4K Views

Medium-High Frequency

~25 min Avg. Time

856 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 (Count Each Query) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler