##### Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/2438.html

# 2438. Range Product Queries of Powers

• Difficulty: Medium.
• Related Topics: .
• Similar Questions: .

## 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] = [lefti, righti]. Each queries[i] represents a query where you have to find the product of all powers[j] with lefti <= j <= righti.

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

Example 1:

Input: n = 15, queries = [[0,1],[2,2],[0,3]]
Output: [2,4,64]
Explanation:
For n = 15, powers = [1,2,4,8]. It can be shown that powers cannot be a smaller size.
Answer to 1st query: powers * powers = 1 * 2 = 2.
Answer to 2nd query: powers = 4.
Answer to 3rd query: powers * powers * powers * powers = 1 * 2 * 4 * 8 = 64.
Each answer modulo 10^9 + 7 yields the same answer, so [2,4,64] is returned.


Example 2:

Input: n = 2, queries = [[0,0]]
Output: 
Explanation:
For n = 2, powers = .
The answer to the only query is powers = 2. The answer modulo 10^9 + 7 is the same, so  is returned.


Constraints:

• 1 <= n <= 10^9

• 1 <= queries.length <= 10^5

• 0 <= starti <= endi < powers.length

## Solution (Java, C++, Python)

• class Solution {
private static final int MOD = (int) 1e9 + 7;

public int[] productQueries(int n, int[][] queries) {
int[] powers = new int[Integer.bitCount(n)];
for (int i = 0; n > 0; ++i) {
int x = n & -n;
powers[i] = x;
n -= x;
}
int[] ans = new int[queries.length];
for (int i = 0; i < ans.length; ++i) {
long x = 1;
int l = queries[i], r = queries[i];
for (int j = l; j <= r; ++j) {
x = (x * powers[j]) % MOD;
}
ans[i] = (int) x;
}
return ans;
}
}

• class Solution {
public:
const int mod = 1e9 + 7;

vector<int> productQueries(int n, vector<vector<int>>& queries) {
vector<int> powers;
while (n) {
int x = n & -n;
powers.emplace_back(x);
n -= x;
}
vector<int> ans;
for (auto& q : queries) {
int l = q, r = q;
long long x = 1l;
for (int j = l; j <= r; ++j) {
x = (x * powers[j]) % mod;
}
ans.emplace_back(x);
}
return ans;
}
};

• class Solution:
def productQueries(self, n: int, queries: List[List[int]]) -> List[int]:
powers = []
while n:
x = n & -n
powers.append(x)
n -= x
mod = 10**9 + 7
ans = []
for l, r in queries:
x = 1
for y in powers[l : r + 1]:
x = (x * y) % mod
ans.append(x)
return ans


• func productQueries(n int, queries [][]int) []int {
var mod int = 1e9 + 7
powers := []int{}
for n > 0 {
x := n & -n
powers = append(powers, x)
n -= x
}
ans := make([]int, len(queries))
for i, q := range queries {
l, r := q, q
x := 1
for _, y := range powers[l : r+1] {
x = (x * y) % mod
}
ans[i] = x
}
return ans
}


Explain:

nope.

Complexity:

• Time complexity : O(n).
• Space complexity : O(n).