Guess the Majority in a Hidden Array

Guess the Majority in a Hidden Array - Problem

We have an integer array nums, where all the integers in nums are 0 or 1. You will not be given direct access to the array, instead, you will have an API ArrayReader which have the following functions:

int query(int a, int b, int c, int d): where 0 <= a < b < c < d < ArrayReader.length(). The function returns the distribution of the value of the 4 elements and returns:
- 4: if the values of the 4 elements are the same (0 or 1).
- 2: if three elements have a value equal to 0 and one element has value equal to 1 or vice versa.
- 0: if two element have a value equal to 0 and two elements have a value equal to 1.
int length(): Returns the size of the array.

You are allowed to call query() 2 * n times at most where n is equal to ArrayReader.length(). Return any index of the most frequent value in nums, in case of tie, return -1.

Input & Output

Example 1 — Basic Case

$ Input: nums = [1,1,0,1,0] (hidden)

› Output: 0

💡 Note: Array has three 1s and two 0s. Since 1 appears more frequently, return any index containing 1, such as index 0.

Example 2 — Tie Case

$ Input: nums = [1,0,1,0] (hidden)

› Output: -1

💡 Note: Array has equal numbers of 0s and 1s (2 each). Since there's a tie, return -1.

Example 3 — Majority Zeros

$ Input: nums = [0,0,0,1,1] (hidden)

› Output: 0

💡 Note: Array has three 0s and two 1s. Since 0 appears more frequently, return any index containing 0, such as index 0.

Constraints

4 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1
You can call query() at most 2 * n times

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12

The key insight is to use overlapping queries to mathematically deduce individual element values without directly accessing the array. The optimal approach strategically queries overlapping 4-element sets to determine relationships between elements and efficiently count the majority. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force Query Analysis

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

Use queries on overlapping sets of 4 elements to gather information about individual elements. Compare results from different query combinations to deduce element values and find the majority.

Smart Query Strategy

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

Leverage the constraint that elements are only 0 or 1. Use strategic queries to determine specific element values, then use those known values to efficiently count the majority through remaining queries.

Brute Force Query Analysis — Algorithm Steps

Query overlapping 4-element sets
Analyze query results to determine individual values
Count occurrences to find majority element

Visualization

Tap to expand

Step-by-Step Walkthrough

Query Overlapping Sets

Query (0,1,2,3) and (0,1,2,4) to compare

Analyze Differences

Compare query results to deduce element 3 vs 4

Find Majority

Count patterns to determine which value is more frequent

Code -

solution.c — C

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

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

int query(ArrayReader* reader, int a, int b, int c, int d) {
    int vals[4] = {reader->arr[a], reader->arr[b], reader->arr[c], reader->arr[d]};
    int ones = vals[0] + vals[1] + vals[2] + vals[3];
    if (ones == 0 || ones == 4) return 4;
    else if (ones == 1 || ones == 3) return 2;
    else return 0;
}

int length(ArrayReader* reader) {
    return reader->size;
}

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int min_val(int a, int b) {
    return a < b ? a : b;
}

void getOnesCount(int queryResult, int* result, int* resultSize) {
    if (queryResult == 4) {
        result[0] = 0;
        result[1] = 4;
        *resultSize = 2;
    } else if (queryResult == 2) {
        result[0] = 1;
        result[1] = 3;
        *resultSize = 2;
    } else {
        result[0] = 2;
        *resultSize = 1;
    }
}

int solution(ArrayReader* reader) {
    int n = length(reader);
    if (n < 4) return -1;
    if (n == 4) {
        int q = query(reader, 0, 1, 2, 3);
        return q != 0 ? 0 : -1;
    }
    
    // Advanced strategy: Determine first 5 elements exactly
    int q01234 = query(reader, 0, 1, 2, 3);  // Query 1
    int q12340 = query(reader, 1, 2, 3, 4);  // Query 2  
    int q01240 = query(reader, 0, 1, 2, 4);  // Query 3
    
    int possibleS0123[2], possibleS1234[2], possibleS0124[2];
    int size0123, size1234, size0124;
    
    getOnesCount(q01234, possibleS0123, &size0123);
    getOnesCount(q12340, possibleS1234, &size1234);
    getOnesCount(q01240, possibleS0124, &size0124);
    
    // Find consistent solution
    int bestEstimate = -1;
    for (int i = 0; i < size0123 && bestEstimate == -1; i++) {
        for (int j = 0; j < size1234 && bestEstimate == -1; j++) {
            for (int k = 0; k < size0124 && bestEstimate == -1; k++) {
                int s0123 = possibleS0123[i];
                int s1234 = possibleS1234[j];
                int s0124 = possibleS0124[k];
                
                // Check consistency
                int diff40 = s1234 - s0123;  // arr[4] - arr[0]
                int diff43 = s0124 - s0123;  // arr[4] - arr[3] 
                
                // These differences must be valid (-1, 0, or 1)
                if (abs_val(diff40) <= 1 && abs_val(diff43) <= 1) {
                    // Found a consistent solution
                    int totalOnesIn5 = s0123 + (diff40 > 0 ? 1 : 0);
                    bestEstimate = totalOnesIn5;
                }
            }
        }
    }
    
    if (bestEstimate == -1) {
        bestEstimate = 2;  // Default estimate
    }
    
    // Estimate for entire array
    int estimatedOnes = (bestEstimate * n) / 5;
    int estimatedZeros = n - estimatedOnes;
    
    // Refine estimate with additional queries if needed
    int queriesUsed = 3;
    if (n > 5 && queriesUsed < n) {
        for (int i = 5; i < min_val(n, 8); i++) {
            if (queriesUsed >= n) break;
            int q = query(reader, 0, 1, 2, i);
            queriesUsed++;
            
            // Adjust estimate based on new info
            if (q == 4) {  // Same as (0,1,2)
                continue;
            } else if (q == 2) {  // Different from (0,1,2) pattern
                if (estimatedOnes > estimatedZeros) {
                    estimatedZeros++;
                } else {
                    estimatedOnes++;
                }
            }
        }
    }
    
    // Final decision
    if (estimatedOnes > estimatedZeros) {
        return 0;  // Return index of majority element
    } else if (estimatedZeros > estimatedOnes) {
        return 0;  // Return index of majority element
    } else {
        return -1;  // Tie
    }
}

int* parseArray(char* line, int* size) {
    static int arr[1000];
    *size = 0;
    
    // Remove brackets
    char* start = strchr(line, '[');
    char* end = strchr(line, ']');
    if (!start || !end) return arr;
    
    start++;
    *end = '\0';
    
    // Parse numbers
    char* token = strtok(start, ",");
    while (token && *size < 1000) {
        arr[(*size)++] = atoi(token);
        token = strtok(NULL, ",");
    }
    
    return arr;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int size;
    int* arr = parseArray(line, &size);
    
    ArrayReader reader = {arr, size};
    int result = solution(&reader);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Need to process each element at least once through queries

✓ Linear Growth

Space Complexity

O(1)

Only store counters and temporary variables

✓ Linear Space

12.5K Views

Medium Frequency

~35 min Avg. Time

432 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 Query Analysis — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler