Range Product Queries of Powers - Practice Coding Problems

Range Product Queries of Powers - Problem

Range Product Queries of Powers

Imagine you have a positive integer n and need to break it down into its binary representation using powers of 2. For example, if n = 13, then 13 = 8 + 4 + 1 = 2³ + 2² + 2⁰.

Given this breakdown, you create an array called powers containing these powers of 2 in non-decreasing order. For n = 13, the array would be [1, 4, 8] (representing [2⁰, 2², 2³]).

Now comes the interesting part! You're given multiple range queries, where each query asks: "What's the product of all powers from index left to index right?"

Since these products can become extremely large, return each answer modulo 10⁹ + 7.

Goal: Efficiently compute range products of powers of 2 that sum to n.
Input: A positive integer n and an array of range queries.
Output: An array of products for each query, modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Case

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

› Output: [32, 32]

💡 Note: n = 13 = 1 + 4 + 8 (binary: 1101), so powers = [1,4,8]. Query [0,2]: 1×4×8 = 32. Query [1,2]: 4×8 = 32.

example_2.py — Single Element

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

› Output: [8]

💡 Note: n = 8 = 2³, so powers = [8]. Query [0,0] returns powers[0] = 8.

example_3.py — Large Powers

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

› Output: [4, 32]

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

Constraints

1 ≤ n ≤ 10⁹
1 ≤ queries.length ≤ 10⁵
0 ≤ left_i ≤ right_i < powers.length
powers.length ≤ 30 (since n ≤ 10⁹ < 2³⁰)

Visualization

Tap to expand

Understanding the Visualization

Binary Decomposition

Convert n to its binary representation to find required powers of 2

Build Powers Array

Create sorted array of powers: [2^0, 2^2, 2^3, ...] for set bits

Optimize with Prefix Products

Precompute cumulative products to answer any range query in O(1)

Handle Large Numbers

Apply modular arithmetic throughout to keep numbers manageable

Key Takeaway

🎯 Key Insight: By preprocessing powers and prefix products, we transform an O(q × log n) problem into O(log n + q), making it optimal for multiple queries on the same powers array.

Asked in

G Google 25 ⊞ Microsoft 18 a Amazon 15 f Meta 12

The optimal solution uses prefix products to answer range queries in O(1) time. First, extract powers of 2 from n using bit manipulation. Then build a prefix products array where each element contains the product of all previous powers. For any range [left, right], the product equals prefix[right+1] / prefix[left] using modular arithmetic with modular inverse for division.

Common Approaches

Approach	Time	Space	Notes
✓ Prefix Products (Optimal)	O(log n + q)	O(log n)	Precompute prefix products to answer queries in O(1) time

Prefix Products (Optimal) — Algorithm Steps

Extract powers of 2 from n using bit manipulation
Build prefix products array where prefix[i] = product of powers[0] to powers[i-1]
For each query [left, right], use formula: prefix[right+1] / prefix[left]
Handle division in modular arithmetic using modular inverse
Return results for all queries

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Prefix Array

Create prefix[i] = product of first i elements

Range Product Formula

Product[left,right] = prefix[right+1] / prefix[left]

Modular Inverse

Handle division using modular inverse for modular arithmetic

Code -

solution.c — C

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

const int MOD = 1000000007;

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

long long modInverse(long long a, long long m) {
    return modPow(a, m - 2, m);
}

int* productQueries(int n, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    // Extract powers of 2 from n
    int powers[32];
    int powerCount = 0;
    int bitPos = 0;
    
    while (n > 0) {
        if (n & 1) {
            powers[powerCount++] = 1 << bitPos;
        }
        n >>= 1;
        bitPos++;
    }
    
    // Build prefix products
    long long prefix[33];
    prefix[0] = 1;
    for (int i = 0; i < powerCount; i++) {
        prefix[i + 1] = (prefix[i] * powers[i]) % MOD;
    }
    
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        int left = queries[i][0];
        int right = queries[i][1];
        long long numerator = prefix[right + 1];
        long long denominator = prefix[left];
        long long product = (numerator * modInverse(denominator, MOD)) % MOD;
        result[i] = product;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n + q)

O(log n) to build powers and prefix arrays + O(q) to answer all queries

⚡ Linearithmic

Space Complexity

O(log n)

Space for powers and prefix products arrays

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

875 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

Prefix Products (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler