Range Product Queries of Powers

Range Product Queries of Powers - Problem

Given a positive integer n, there exists a 0-indexed array called powers, composed of the minimum number of powers of 2 that sum to n. The array is sorted in non-decreasing order, and there is only one way to form the array.

You are also given a 0-indexed 2D integer array queries, where queries[i] = [left_i, right_i]. Each queries[i] represents a query where you have to find the product of all powers[j] with left_i ≤ j ≤ right_i.

Return an array answers, equal in length to queries, where answers[i] is the answer to the i^th query. Since the answer to the i^th query may be too large, each answers[i] should be returned modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Case

$ Input: n = 15, queries = [[0,1],[2,2]]

› Output: [2,4]

💡 Note: 15 = 8+4+2+1, so powers = [1,2,4,8]. Query [0,1]: 1×2=2. Query [2,2]: 4.

Example 2 — Single Element

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

› Output: [2]

💡 Note: 2 = 2¹, so powers = [2]. Query [0,0]: 2.

Example 3 — Large Range

$ Input: n = 31, queries = [[0,4]]

› Output: [1024]

💡 Note: 31 = 16+8+4+2+1, so powers = [1,2,4,8,16]. Query [0,4]: 1×2×4×8×16=1024.

Constraints

1 ≤ n ≤ 10⁹
1 ≤ queries.length ≤ 10⁵
0 ≤ left_i ≤ right_i < popcount(n)

Visualization

Tap to expand

Asked in

G Google 12 M Microsoft 8 a Amazon 6

The key insight is that products of powers of 2 can be calculated as 2^(sum of exponents). The optimal approach uses prefix sums to compute range exponent sums in O(1) time per query. Time: O(log n + q log MOD), Space: O(log n)

Common Approaches

✓ Brute Force

⏱️ Time: O(q × k) Space: O(log n)

First decompose n into powers of 2 by examining its binary representation. For each query, iterate through the range and multiply all powers together with modular arithmetic.

Prefix Sum Optimization

⏱️ Time: O(log n + q log MOD) Space: O(log n)

Convert the product calculation to sum of exponents since product of powers of 2 equals 2^(sum of exponents). Use prefix sums to get range sums in O(1) time.

Brute Force — Algorithm Steps

Step 1: Extract powers of 2 from binary representation of n
Step 2: For each query, multiply powers in range [left, right]
Step 3: Apply modulo 10^9 + 7 to prevent overflow

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Powers

Convert n to powers of 2 array

Query Range

Multiply elements in [left, right]

Result

Return products with modulo

Code -

solution.c — C

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

int* solution(int n, int** queries, int queriesSize, int* returnSize) {
    const int MOD = 1000000007;
    
    // Extract powers of 2 from binary representation
    long long powers[64];
    int powerCount = 0;
    int bitPos = 0;
    int temp = n;
    
    while (temp > 0) {
        if (temp & 1) {
            // Store 2^bitPos % MOD to avoid overflow
            long long power = 1;
            for (int k = 0; k < bitPos; k++) {
                power = (power * 2) % MOD;
            }
            powers[powerCount++] = power;
        }
        temp >>= 1;
        bitPos++;
    }
    
    int* answers = malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        int left = queries[i][0], right = queries[i][1];
        long long product = 1;
        for (int j = left; j <= right; j++) {
            product = (product * powers[j]) % MOD;
        }
        answers[i] = (int)product;
    }
    
    return answers;
}

int main() {
    int n;
    scanf("%d", &n);
    
    // Parse queries array - manual string parsing
    char buffer[10000];
    scanf(" %[^\n]", buffer); // Read the entire line
    
    // Count queries
    int queriesSize = 0;
    for (int i = 0; buffer[i]; i++) {
        if (buffer[i] == '[' && buffer[i+1] != '[') {
            queriesSize++;
        }
    }
    
    int** queries = malloc(queriesSize * sizeof(int*));
    for (int i = 0; i < queriesSize; i++) {
        queries[i] = malloc(2 * sizeof(int));
    }
    
    // Parse the queries
    int idx = 0;
    char* ptr = buffer;
    while (*ptr) {
        if (*ptr == '[' && *(ptr+1) != '[') {
            ptr++;
            sscanf(ptr, "%d,%d", &queries[idx][0], &queries[idx][1]);
            idx++;
        }
        ptr++;
    }
    
    int returnSize;
    int* result = solution(n, queries, queriesSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    // Free memory
    for (int i = 0; i < queriesSize; i++) {
        free(queries[i]);
    }
    free(queries);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(q × k)

q queries times average k powers per query range

✓ Linear Growth

Space Complexity

O(log n)

Powers array stores at most log n powers of 2

⚡ Linearithmic Space

15.3K Views

Medium Frequency

~25 min Avg. Time

487 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler