Find Products of Elements of Big Array - Problem

Find Products of Elements of Big Array

Imagine a magical array called big_nums that's constructed in a fascinating way! For every positive integer, we create its powerful array - which contains all the powers of 2 that sum up to that number (based on its binary representation).

For example:
• Number 13 has binary 1101, so its powerful array is [1, 4, 8] (positions of 1-bits)
• Number 23 has binary 10111, so its powerful array is [1, 2, 4, 16]

The big_nums array is formed by concatenating all these powerful arrays in order:
[1, 2, 1, 2, 4, 1, 4, 2, 4, 1, 2, 4, 8, ...]

Your task: Given multiple queries [from, to, mod], calculate the product of elements from index from to to (inclusive) in big_nums, modulo mod.

Can you solve this efficiently without actually building the massive array?

Input & Output

example_1.py — Basic Query

$ Input: queries = [[0, 2, 3]]

› Output: [2]

💡 Note: big_nums = [1, 2, 1, 2, 4, ...]. Range [0,2] contains [1,2,1]. Product = 1×2×1 = 2. Since 2 < 3, result is 2.

example_2.py — Multiple Queries

$ Input: queries = [[2, 5, 4], [0, 2, 3]]

› Output: [0, 2]

💡 Note: Range [2,5] = [1,2,4,1] → product = 8 ≡ 0 (mod 4). Range [0,2] = [1,2,1] → product = 2.

example_3.py — Large Numbers

$ Input: queries = [[10, 15, 7]]

› Output: [1]

💡 Note: For large ranges, we need efficient calculation without building the actual array. The product modulo 7 equals 1.

Constraints

1 ≤ queries.length ≤ 500
queries[i].length == 3
0 ≤ from_i ≤ to_i ≤ 10¹⁵
2 ≤ mod_i ≤ 10⁹
The answer is guaranteed to fit in a 32-bit integer.

Visualization

Tap to expand

Asked in

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

The optimal approach uses binary search and bit manipulation to avoid building the massive array. Key insights: (1) Use binary search to map indices to numbers, (2) Count occurrences of each power of 2 mathematically, (3) Apply modular exponentiation for efficient calculation. This achieves O(Q × log²N) time with O(1) space.

Common Approaches

✓ Binary Search + Bit Manipulation

⏱️ Time: O(Q * log²N) Space: O(1)

Instead of building the array, use binary search to determine which number corresponds to any given index, then use mathematical properties of powers of 2 to calculate products efficiently.

Brute Force (Build Array)

⏱️ Time: O(N + Q*R) Space: O(N)

Generate the powerful arrays for each number sequentially, concatenate them to build big_nums, then answer queries by multiplying elements in the given ranges.

Binary Search + Bit Manipulation — Algorithm Steps

Create a function to count total elements up to number n using bit manipulation
Use binary search to find which number contains a given index
For range queries, count occurrences of each power of 2 in the range
Calculate the product using modular exponentiation

Visualization

Tap to expand

Step-by-Step Walkthrough

Binary Search Setup

Use cumulative count function to find position mapping

Count Powers

Count occurrences of each power of 2 in the range

Calculate Product

Use modular exponentiation for final result

Code -

solution.c — C

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

// Count total set bits in numbers from 1 to n (i.e., total elements in big array up to n)
long long count_bits_up_to(long long n) {
    if (n <= 0) return 0;
    long long result = 0;
    for (int bit = 0; bit < 60; bit++) {
        long long cycle = 1LL << (bit + 1);
        long long complete = (n + 1) / cycle;
        long long rem = (n + 1) % cycle;
        result += complete * (1LL << bit);
        if (rem > (1LL << bit))
            result += rem - (1LL << bit);
    }
    return result;
}

// Given 0-indexed position idx in the big array, find which number it belongs to
// Returns the number; sets *pos_in_num to which set-bit position within that number
long long find_number_at(long long idx, long long *pos_in_num) {
    // Binary search for smallest n such that count_bits_up_to(n) > idx
    long long left = 1, right = 2e15;
    while (left < right) {
        long long mid = left + (right - left) / 2;
        if (count_bits_up_to(mid) <= idx)
            left = mid + 1;
        else
            right = mid;
    }
    long long num = left;
    long long bits_before = count_bits_up_to(num - 1);
    *pos_in_num = idx - bits_before; // which set bit (0-indexed) within num
    return num;
}

// Count how many times bit 'b' (i.e., 2^b) appears in big array for numbers 1..n
// = count of numbers in [1..n] that have bit b set
long long count_bit_b_up_to(long long n, int b) {
    if (n <= 0) return 0;
    long long cycle = 1LL << (b + 1);
    long long complete = (n + 1) / cycle;
    long long rem = (n + 1) % cycle;
    long long cnt = complete * (1LL << b);
    if (rem > (1LL << b))
        cnt += rem - (1LL << b);
    return cnt;
}

// Count total occurrences of 2^b in the big array from index 0..idx (inclusive)
// We need: count_bit_b_up_to(num-1, b) + (number of set bits <= pos_in_num-th set bit in num that equal bit b)
// More precisely: count contributions from full numbers [1..num-1] plus partial contribution from num itself.

// Count how many times 2^b appears in big array positions [0, idx]
long long count_power_in_prefix(long long idx, int b) {
    if (idx < 0) return 0;
    long long pos_in_num;
    long long num = find_number_at(idx, &pos_in_num);
    
    // Full numbers 1..num-1 contribute count_bit_b_up_to(num-1, b)
    long long cnt = count_bit_b_up_to(num - 1, b);
    
    // Partial: within 'num', we want set bits up to pos_in_num-th set bit (0-indexed)
    // Check if bit b is among the first (pos_in_num+1) set bits of num
    if (num & (1LL << b)) {
        // Find the rank of bit b among set bits of num (0-indexed, LSB first)
        int rank = 0;
        for (int i = 0; i < b; i++) {
            if (num & (1LL << i)) rank++;
        }
        if (rank <= pos_in_num) cnt++;
    }
    return cnt;
}

long long mod_pow(long long base, long long exp, long long mod) {
    if (mod == 1) return 0;
    long long result = 1;
    base %= mod;
    while (exp > 0) {
        if (exp & 1) result = result * base % mod;
        base = base * base % mod;
        exp >>= 1;
    }
    return result;
}

int* findProductsOfElements(int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    *returnSize = queriesSize;
    int* results = malloc(queriesSize * sizeof(int));
    
    for (int q = 0; q < queriesSize; q++) {
        long long from_idx = queries[q][0];
        long long to_idx   = queries[q][1];
        long long mod      = queries[q][2];
        
        if (mod == 1) { results[q] = 0; continue; }
        
        long long product = 1;
        // For each bit b, count how many times 2^b appears in [from_idx, to_idx]
        for (int b = 0; b < 60; b++) {
            long long cnt = count_power_in_prefix(to_idx, b) - count_power_in_prefix(from_idx - 1, b);
            if (cnt > 0) {
                product = product * mod_pow(1LL << b, cnt, mod) % mod;
            }
        }
        results[q] = (int)product;
    }
    return results;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    static int queries[100][3];
    static int* query_ptrs[100];
    int queries_size = 0;
    static int queries_col_size[100];
    
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    while (*ptr) {
        if (*ptr == '[') {
            ptr++;
            char* endptr;
            while (*ptr && !(*ptr == '-' || (*ptr >= '0' && *ptr <= '9'))) ptr++;
            queries[queries_size][0] = (int)strtol(ptr, &endptr, 10);
            ptr = endptr;
            while (*ptr && !(*ptr == '-' || (*ptr >= '0' && *ptr <= '9'))) ptr++;
            queries[queries_size][1] = (int)strtol(ptr, &endptr, 10);
            ptr = endptr;
            while (*ptr && !(*ptr == '-' || (*ptr >= '0' && *ptr <= '9'))) ptr++;
            queries[queries_size][2] = (int)strtol(ptr, &endptr, 10);
            ptr = endptr;
            query_ptrs[queries_size] = queries[queries_size];
            queries_col_size[queries_size] = 3;
            queries_size++;
            while (*ptr && *ptr != ']') ptr++;
            if (*ptr == ']') ptr++;
        } else {
            ptr++;
        }
    }
    
    int return_size;
    int* results = findProductsOfElements(query_ptrs, queries_size, queries_col_size, &return_size);
    
    printf("[");
    for (int i = 0; i < return_size; i++) {
        if (i > 0) printf(",");
        printf("%d", results[i]);
    }
    printf("]\n");
    free(results);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(Q * log²N)

Q queries, each requiring log N binary searches and log N bit operations

⚡ Linearithmic

Space Complexity

O(1)

Only uses constant extra space for calculations

✓ Linear Space

42.0K Views

Medium Frequency

~35 min Avg. Time

1.5K 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

Find Products of Elements of Big Array - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Search + Bit Manipulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler