Find Products of Elements of Big Array - Practice Coding Problems

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

Understanding the Visualization

Extract Powers

Each number contributes its binary powers to the sequence

Mathematical Mapping

Use formulas to find position without building array

Efficient Calculation

Count and multiply using modular arithmetic

Key Takeaway

🎯 Key Insight: Instead of building the massive array, use mathematical formulas to count power occurrences and binary search for efficient index mapping!

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

Approach	Time	Space	Notes
✓ Brute Force (Build Array)	O(N + Q*R)	O(N)	Build the big_nums array explicitly and calculate products directly
Binary Search + Bit Manipulation	O(Q * log²N)	O(1)	Use binary search to find position mapping and bit manipulation for efficient calculation

Brute Force (Build Array) — Algorithm Steps

For each positive integer i, generate its powerful array by finding powers of 2 in its binary representation
Concatenate all powerful arrays to build big_nums array
For each query [from, to, mod], multiply elements from big_nums[from] to big_nums[to]
Apply modulo operation to prevent overflow

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Powerful Arrays

For each number, extract powers of 2 from binary representation

Concatenate Arrays

Combine all powerful arrays into one big sequence

Answer Queries

Multiply elements in specified ranges

Code -

solution.c — C

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

int* getPowerfulArray(int x, int* size) {
    int* powers = malloc(32 * sizeof(int));
    *size = 0;
    int power = 1;
    while (x > 0) {
        if (x & 1) {
            powers[(*size)++] = power;
        }
        x >>= 1;
        power <<= 1;
    }
    return powers;
}

int* findProductsOfElements(int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    int* bigNums = malloc(100000 * sizeof(int));
    int bigNumsSize = 0;
    
    int i = 1;
    while (bigNumsSize < 100000) {
        int powerfulSize;
        int* powerful = getPowerfulArray(i, &powerfulSize);
        for (int j = 0; j < powerfulSize && bigNumsSize < 100000; j++) {
            bigNums[bigNumsSize++] = powerful[j];
        }
        free(powerful);
        i++;
    }
    
    *returnSize = queriesSize;
    int* results = malloc(queriesSize * sizeof(int));
    
    for (int q = 0; q < queriesSize; q++) {
        int fromIdx = queries[q][0];
        int toIdx = queries[q][1];
        int mod = queries[q][2];
        
        long long product = 1;
        for (int j = fromIdx; j <= toIdx; j++) {
            product = (product * bigNums[j]) % mod;
        }
        results[q] = (int)product;
    }
    
    free(bigNums);
    return results;
}

Time & Space Complexity

Time Complexity

⏱️

O(N + Q*R)

N to build array up to max index, Q queries each taking R time for range multiplication

✓ Linear Growth

Space Complexity

O(N)

Store the entire big_nums array up to maximum required index

✓ 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Build Array) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler