Queries to calculate sum of array elements present at every Yth index starting from the index X
Last Updated :
02 May, 2023
Given an array arr[] of size N, and an array Q[][] with each row representing a query of the form { X, Y }, the task for each query is to find the sum of array elements present at indices X, X + Y, X + 2 * Y + ...
Examples:
Input: arr[] = { 1, 2, 7, 5, 4 }, Q[][] = { { 2, 1 }, { 3, 2 } }
Output: 16 5
Explanation:
Query1: arr[2] + arr[2 + 1] + arr[2 + 2] = 7 + 5 + 4 = 16.
Query2: arr[3] = 5.
Input: arr[] = { 3, 6, 1, 8, 0 } Q[][] = { { 0, 2 } }
Output: 4
Naive Approach: The simplest approach to solve this problem is to traverse the array for each query and print the sum of arr[x] + arr[x + y] + arr[x + 2 * y] + ...
Below is the implementation of the above approach:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to Find the sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
// for all queries
void querySum(int arr[], int N,
int Q[][2], int M)
{
// Iterate over each query
for (int i = 0; i < M; i++) {
int x = Q[i][0];
int y = Q[i][1];
// Stores the sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
int sum = 0;
// Traverse the array and calculate
// the sum of the expression
while (x < N) {
// Update sum
sum += arr[x];
// Update x
x += y;
}
cout << sum << " ";
}
}
// Driver Code
int main()
{
int arr[] = { 1, 2, 7, 5, 4 };
int Q[][2] = { { 2, 1 }, { 3, 2 } };
int N = sizeof(arr) / sizeof(arr[0]);
int M = sizeof(Q) / sizeof(Q[0]);
querySum(arr, N, Q, M);
return 0;
}
// Java program for the above approach
import java.util.*;
class GFG{
// Function to Find the sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
// for all queries
static void querySum(int arr[], int N,
int Q[][], int M)
{
// Iterate over each query
for(int i = 0; i < M; i++)
{
int x = Q[i][0];
int y = Q[i][1];
// Stores the sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
int sum = 0;
// Traverse the array and calculate
// the sum of the expression
while (x < N)
{
// Update sum
sum += arr[x];
// Update x
x += y;
}
System.out.print(sum + " ");
}
}
// Driver Code
public static void main(String[] args)
{
int arr[] = { 1, 2, 7, 5, 4 };
int Q[][] = { { 2, 1 }, { 3, 2 } };
int N = arr.length;
int M = Q.length;
querySum(arr, N, Q, M);
}
}
// This code is contributed by 29AjayKumar
# Python3 program for the above approach
# Function to Find the sum of
# arr[x]+arr[x+y]+arr[x+2*y] + ...
# for all queries
def querySum(arr, N, Q, M):
# Iterate over each query
for i in range(M):
x = Q[i][0]
y = Q[i][1]
# Stores the sum of
# arr[x]+arr[x+y]+arr[x+2*y] + ...
sum = 0
# Traverse the array and calculate
# the sum of the expression
while (x < N):
# Update sum
sum += arr[x]
# Update x
x += y
print(sum, end=" ")
# Driver Code
if __name__ == '__main__':
arr = [ 1, 2, 7, 5, 4 ];
Q = [ [ 2, 1 ], [3, 2 ] ]
N = len(arr)
M = len(Q)
querySum(arr, N, Q, M)
# This code is contributed by mohit kumar 29
// C# program for the above approach
using System;
class GFG
{
// Function to Find the sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
// for all queries
static void querySum(int []arr, int N,
int [,]Q, int M)
{
// Iterate over each query
for(int i = 0; i < M; i++)
{
int x = Q[i, 0];
int y = Q[i, 1];
// Stores the sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
int sum = 0;
// Traverse the array and calculate
// the sum of the expression
while (x < N)
{
// Update sum
sum += arr[x];
// Update x
x += y;
}
Console.Write(sum + " ");
}
}
// Driver Code
public static void Main(String[] args)
{
int []arr = { 1, 2, 7, 5, 4 };
int [,]Q = { { 2, 1 }, { 3, 2 } };
int N = arr.Length;
int M = Q.GetLength(0);
querySum(arr, N, Q, M);
}
}
// This code is contributed by shikhasingrajput
<script>
// JavaScript program for the above approach
// Function to Find the sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
// for all queries
function querySum(arr, N, Q, M)
{
// Iterate over each query
for (let i = 0; i < M; i++) {
let x = Q[i][0];
let y = Q[i][1];
// Stores the sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
let sum = 0;
// Traverse the array and calculate
// the sum of the expression
while (x < N) {
// Update sum
sum += arr[x];
// Update x
x += y;
}
document.write(sum + " ");
}
}
// Driver Code
let arr = [ 1, 2, 7, 5, 4 ];
let Q = [ [ 2, 1 ], [ 3, 2 ] ];
let N = arr.length;
let M = Q.length;
querySum(arr, N, Q, M);
// This code is contributed by Surbhi Tyagi.
</script>
Time Complexity: O(|Q| * O(N))
Auxiliary Space: O(1)
The problem can be solved by precomputing the value of the given expression for all possible values of { X, Y } using Dynamic programming technique and the Square Root Decomposition technique. The following are the recurrence relation:
if i + j < N
dp[i][j] = dp[i + j][j] + arr[i]
Otherwise,
dp[i][j] = arr[i]
dp[i][j]: Stores the sum of the given expression where X = i, Y = j
Follow the steps below to solve the problem:
- Initialize a 2D array, say dp[][], to store the sum of expression for all possible values of X and Y, where Y is less than or equal to sqrt(N).
- Fill the dp[][] array using tabulation method.
- Traverse the array Q[][]. For each query, check if the value of Q[i][1] is less than or equal to sqrt(N) or not. If found to be true, then print the value of dp[Q[i][0]][Q[i][1]].
- Otherwise, calculate the value of the expression using the above naive approach and print the calculated value.
Below is the implementation of our approach:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
const int sz = 20;
const int sqr = int(sqrt(sz)) + 1;
// Function to sum of arr[x]+arr[x+y]+arr[x+2*y] + ...
// for all possible values of X and Y, where Y is
// less than or equal to sqrt(N).
void precomputeExpressionForAllVal(int arr[], int N,
int dp[sz][sqr])
{
// Iterate over all possible values of X
for (int i = N - 1; i >= 0; i--) {
// Precompute for all possible values
// of an expression such that y <= sqrt(N)
for (int j = 1; j <= sqrt(N); j++) {
// If i + j less than N
if (i + j < N) {
// Update dp[i][j]
dp[i][j] = arr[i] + dp[i + j][j];
}
else {
// Update dp[i][j]
dp[i][j] = arr[i];
}
}
}
}
// Function to Find the sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
// for all queries
int querySum(int arr[], int N,
int Q[][2], int M)
{
// dp[x][y]: Stores sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
int dp[sz][sqr];
precomputeExpressionForAllVal(arr, N, dp);
// Traverse the query array, Q[][]
for (int i = 0; i < M; i++) {
int x = Q[i][0];
int y = Q[i][1];
// If y is less than or equal
// to sqrt(N)
if (y <= sqrt(N)) {
cout << dp[x][y] << " ";
continue;
}
// Stores the sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
int sum = 0;
// Traverse the array, arr[]
while (x < N) {
// Update sum
sum += arr[x];
// Update x
x += y;
}
cout << sum << " ";
}
}
// Driver Code
int main()
{
int arr[] = { 1, 2, 7, 5, 4 };
int Q[][2] = { { 2, 1 }, { 3, 2 } };
int N = sizeof(arr) / sizeof(arr[0]);
int M = sizeof(Q) / sizeof(Q[0]);
querySum(arr, N, Q, M);
return 0;
}
// Java program for the above approach
import java.util.*;
class GFG{
static int sz = 20;
static int sqr = (int)(Math.sqrt(sz)) + 1;
// Function to sum of arr[x]+arr[x+y]+arr[x+2*y] + ...
// for all possible values of X and Y, where Y is
// less than or equal to Math.sqrt(N).
static void precomputeExpressionForAllVal(int arr[],
int N,
int dp[][])
{
// Iterate over all possible values of X
for(int i = N - 1; i >= 0; i--)
{
// Precompute for all possible values
// of an expression such that y <= Math.sqrt(N)
for(int j = 1; j <= Math.sqrt(N); j++)
{
// If i + j less than N
if (i + j < N)
{
// Update dp[i][j]
dp[i][j] = arr[i] + dp[i + j][j];
}
else
{
// Update dp[i][j]
dp[i][j] = arr[i];
}
}
}
}
// Function to Find the sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
// for all queries
static void querySum(int arr[], int N,
int Q[][], int M)
{
// dp[x][y]: Stores sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
int [][]dp = new int[sz][sqr];
precomputeExpressionForAllVal(arr, N, dp);
// Traverse the query array, Q[][]
for(int i = 0; i < M; i++)
{
int x = Q[i][0];
int y = Q[i][1];
// If y is less than or equal
// to Math.sqrt(N)
if (y <= Math.sqrt(N))
{
System.out.print(dp[x][y] + " ");
continue;
}
// Stores the sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
int sum = 0;
// Traverse the array, arr[]
while (x < N)
{
// Update sum
sum += arr[x];
// Update x
x += y;
}
System.out.print(sum + " ");
}
}
// Driver Code
public static void main(String[] args)
{
int arr[] = { 1, 2, 7, 5, 4 };
int Q[][] = { { 2, 1 }, { 3, 2 } };
int N = arr.length;
int M = Q.length;
querySum(arr, N, Q, M);
}
}
// This code is contributed by shikhasingrajput
# python program for the above approach
import math
sz = 20
sqr = int(math.sqrt(sz)) + 1
# Function to sum of arr[x]+arr[x+y]+arr[x+2*y] + ...
# for all possible values of X and Y, where Y is
# less than or equal to sqrt(N).
def precomputeExpressionForAllVal(arr, N, dp):
# Iterate over all possible values of X
for i in range(N - 1, -1, -1) :
# Precompute for all possible values
# of an expression such that y <= sqrt(N)
for j in range (1,int(math.sqrt(N)) + 1):
# If i + j less than N
if (i + j < N):
# Update dp[i][j]
dp[i][j] = arr[i] + dp[i + j][j]
else:
# Update dp[i][j]
dp[i][j] = arr[i]
# Function to Find the sum of
# arr[x]+arr[x+y]+arr[x+2*y] + ...
# for all queries
def querySum(arr, N, Q, M):
# dp[x][y]: Stores sum of
# arr[x]+arr[x+y]+arr[x+2*y] + ...
dp = [ [0 for x in range(sz)]for x in range(sqr)]
precomputeExpressionForAllVal(arr, N, dp)
# Traverse the query array, Q[][]
for i in range (0,M):
x = Q[i][0]
y = Q[i][1]
# If y is less than or equal
# to sqrt(N)
if (y <= math.sqrt(N)):
print(dp[x][y])
continue
# Stores the sum of
# arr[x]+arr[x+y]+arr[x+2*y] + ...
sum = 0
# Traverse the array, arr[]
while (x < N):
# Update sum
sum += arr[x]
# Update x
x += y
print(sum)
# Driver Code
arr = [ 1, 2, 7, 5, 4 ]
Q = [ [ 2, 1 ], [ 3, 2]]
N = len(arr)
M = len(Q[0])
querySum(arr, N, Q, M)
# This code is contributed by amreshkumar3.
// C# program for the above approach
using System;
class GFG{
static int sz = 20;
static int sqr = (int)(Math.Sqrt(sz)) + 1;
// Function to sum of arr[x]+arr[x+y]+arr[x+2*y] + ...
// for all possible values of X and Y, where Y is
// less than or equal to Math.Sqrt(N).
static void precomputeExpressionForAllVal(int []arr,
int N,
int [,]dp)
{
// Iterate over all possible values of X
for(int i = N - 1; i >= 0; i--)
{
// Precompute for all possible values
// of an expression such that y <= Math.Sqrt(N)
for(int j = 1; j <= Math.Sqrt(N); j++)
{
// If i + j less than N
if (i + j < N)
{
// Update dp[i,j]
dp[i, j] = arr[i] + dp[i + j, j];
}
else
{
// Update dp[i,j]
dp[i, j] = arr[i];
}
}
}
}
// Function to Find the sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
// for all queries
static void querySum(int []arr, int N,
int [,]Q, int M)
{
// dp[x,y]: Stores sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
int [,]dp = new int[sz, sqr];
precomputeExpressionForAllVal(arr, N, dp);
// Traverse the query array, Q[,]
for(int i = 0; i < M; i++)
{
int x = Q[i, 0];
int y = Q[i, 1];
// If y is less than or equal
// to Math.Sqrt(N)
if (y <= Math.Sqrt(N))
{
Console.Write(dp[x, y] + " ");
continue;
}
// Stores the sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
int sum = 0;
// Traverse the array, []arr
while (x < N)
{
// Update sum
sum += arr[x];
// Update x
x += y;
}
Console.Write(sum + " ");
}
}
// Driver Code
public static void Main(String[] args)
{
int []arr = { 1, 2, 7, 5, 4 };
int [,]Q = { { 2, 1 }, { 3, 2 } };
int N = arr.Length;
int M = Q.GetLength(0);
querySum(arr, N, Q, M);
}
}
// This code is contributed by shikhasingrajput
<script>
// javascript program of the above approach
let sz = 20;
let sqr = (Math.sqrt(sz)) + 1;
// Function to sum of arr[x]+arr[x+y]+arr[x+2*y] + ...
// for all possible values of X and Y, where Y is
// less than or equal to Math.sqrt(N).
function precomputeExpressionForAllVal(arr, N, dp)
{
// Iterate over all possible values of X
for(let i = N - 1; i >= 0; i--)
{
// Precompute for all possible values
// of an expression such that y <= Math.sqrt(N)
for(let j = 1; j <= Math.sqrt(N); j++)
{
// If i + j less than N
if (i + j < N)
{
// Update dp[i][j]
dp[i][j] = arr[i] + dp[i + j][j];
}
else
{
// Update dp[i][j]
dp[i][j] = arr[i];
}
}
}
}
// Function to Find the sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
// for all queries
function querySum(arr, N, Q, M)
{
let dp = new Array(sz);
// Loop to create 2D array using 1D array
for (var i = 0; i < dp.length; i++) {
dp[i] = new Array(2);
}
// Loop to create 2D array using 1D array
for (var i = 0; i < dp.length; i++) {
dp[i] = new Array(2);
}
precomputeExpressionForAllVal(arr, N, dp);
// Traverse the query array, Q[][]
for(let i = 0; i < M; i++)
{
let x = Q[i][0];
let y = Q[i][1];
// If y is less than or equal
// to Math.sqrt(N)
if (y <= Math.sqrt(N))
{
document.write(dp[x][y] + " ");
continue;
}
// Stores the sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
let sum = 0;
// Traverse the array, arr[]
while (x < N)
{
// Update sum
sum += arr[x];
// Update x
x += y;
}
Sdocument.write(sum + " ");
}
}
// Driver Code
// Given array
let arr = [ 1, 2, 7, 5, 4 ];
let Q= [[ 2, 1 ], [ 3, 2 ]]
let N = arr.length;
let M = Q.length;
querySum(arr, N, Q, M);
// This code is contributed by chinmoy1997pal.
</script>
Time complexity: O(N * sqrt(N) + |Q| * sqrt(N))
Auxiliary Space:O(N * sqrt(N))
Approach 2B: Space optimization
In the previous approach, we can see that in the function precomputeExpressionForAllVal we use 2d dp which is not required because dp[i][j] is dependent upon arr[i] and dp[i + j][j] so we can optimize its space complexity by using 1d DP.
Implementation:
- Initialize dp to all zeros and Iterate over all possible values of X from N-1 down to 0.
- Precompute for all possible values of an expression such that y <= sqrt(N).
- If i + j is less than N, update dp[i] to add arr[i+j].
- Define the function querySum to take in the input parameters arr, N, Q, and M.
- Traverse the query array Q[][], where each query is represented by a pair of integers {x, y}.
- If y is less than or equal to sqrt(N), iterate over arr[x], arr[x+y], arr[x+2y],..., until the end of the array and print their sum.
- Otherwise, for each query, initialize sum to zero and traverse the array arr[] starting from index x and incrementing by y.
- Add each element arr[i] to sum until x is less than N.
- Print the final sum for each query.
Example:
C++
#include <bits/stdc++.h>
using namespace std;
// Function to sum of arr[x]+arr[x+y]+arr[x+2*y] + ...
// for all possible values of X and Y, where Y is
// less than or equal to sqrt(N).
void precomputeExpressionForAllVal(int arr[], int N,
int dp[])
{
// Iterate over all possible values of X
for (int i = N - 1; i >= 0; i--) {
// Precompute for all possible values
// of an expression such that y <= sqrt(N)
for (int j = 1; j <= sqrt(N); j++) {
// If i + j less than N
if (i + j < N) {
// Update dp[i+j]
dp[i] += arr[i + j];
}
}
}
}
// Function to Find the sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
// for all queries
void querySum(int arr[], int N, int Q[][2], int M)
{
// Traverse the query array, Q[][]
for (int i = 0; i < M; i++) {
int x = Q[i][0];
int y = Q[i][1];
// If y is less than or equal
// to sqrt(N)
if (y <= sqrt(N)) {
int ans = 0;
for (int j = x; j < N; j += y)
ans += arr[j];
cout << ans << " ";
continue;
}
// Stores the sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
int sum = 0;
// Traverse the array, arr[]
while (x < N) {
// Update sum
sum += arr[x];
// Update x
x += y;
}
cout << sum << " ";
}
}
// Driver Code
int main()
{
int arr[] = { 1, 2, 7, 5, 4 };
int Q[][2] = { { 2, 1 }, { 3, 2 } };
int N = sizeof(arr) / sizeof(arr[0]);
int M = sizeof(Q) / sizeof(Q[0]);
// dp[x]: Stores sum of arr[x]+arr[x+y]+arr[x+2*y] + ...
// for all possible values of X and Y, where Y is
// less than or equal to sqrt(N).
int dp[N] = { 0 };
precomputeExpressionForAllVal(arr, N, dp);
querySum(arr, N, Q, M);
return 0;
}
// this code is contributed by bhardwajji
import java.util.*;
public class Main {
// Function to sum of arr[x]+arr[x+y]+arr[x+2*y] + ...
// for all possible values of X and Y, where Y is
// less than or equal to sqrt(N).
static void precomputeExpressionForAllVal(int[] arr,
int N,
int[] dp)
{
// Iterate over all possible values of X
for (int i = N - 1; i >= 0; i--) {
// Precompute for all possible values
// of an expression such that y <= sqrt(N)
for (int j = 1; j <= Math.sqrt(N); j++) {
// If i + j less than N
if (i + j < N) {
// Update dp[i+j]
dp[i] += arr[i + j];
}
}
}
}
// Function to Find the sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
// for all queries
static void querySum(int[] arr, int N, int[][] Q, int M)
{
// Traverse the query array, Q[][]
for (int i = 0; i < M; i++) {
int x = Q[i][0];
int y = Q[i][1];
// If y is less than or equal
// to sqrt(N)
if (y <= Math.sqrt(N)) {
int ans = 0;
for (int j = x; j < N; j += y)
ans += arr[j];
System.out.print(ans + " ");
continue;
}
// Stores the sum of
// arr[x]+arr[x+y]+arr[x+2*y] + ...
int sum = 0;
// Traverse the array, arr[]
while (x < N) {
// Update sum
sum += arr[x];
// Update x
x += y;
}
System.out.print(sum + " ");
}
}
// Driver Code
public static void main(String[] args)
{
int[] arr = { 1, 2, 7, 5, 4 };
int[][] Q = { { 2, 1 }, { 3, 2 } };
int N = arr.length;
int M = Q.length;
// dp[x]: Stores sum of arr[x]+arr[x+y]+arr[x+2*y] +
// ... for all possible values of X and Y, where Y
// is less than or equal to sqrt(N).
int[] dp = new int[N];
precomputeExpressionForAllVal(arr, N, dp);
querySum(arr, N, Q, M);
}
}
import math
def precompute_expression_for_all_val(arr, N, dp):
# Iterate over all possible values of X
for i in range(N - 1, -1, -1):
# Precompute for all possible values
# of an expression such that y <= sqrt(N)
for j in range(1, int(math.sqrt(N)) + 1):
# If i + j less than N
if i + j < N:
# Update dp[i+j]
dp[i] += arr[i + j]
def query_sum(arr, N, Q, M):
# Traverse the query array, Q[][]
for i in range(M):
x = Q[i][0]
y = Q[i][1]
# If y is less than or equal
# to sqrt(N)
if y <= int(math.sqrt(N)):
ans = 0
for j in range(x, N, y):
ans += arr[j]
print(ans, end=" ")
continue
# Stores the sum of
# arr[x]+arr[x+y]+arr[x+2*y] + ...
sum = 0
# Traverse the array, arr[]
while x < N:
# Update sum
sum += arr[x]
# Update x
x += y
print(sum, end=" ")
# Driver Code
arr = [1, 2, 7, 5, 4]
Q = [[2, 1], [3, 2]]
N = len(arr)
M = len(Q)
# dp[x]: Stores sum of arr[x]+arr[x+y]+arr[x+2*y] +
# ... for all possible values of X and Y, where Y
# is less than or equal to sqrt(N).
dp = [0] * N
precompute_expression_for_all_val(arr, N, dp)
query_sum(arr, N, Q, M)
// C# implementation of the above code
using System;
class Program {
static void PrecomputeExpressionForAllVal(int[] arr,
int N,
int[] dp)
{
for (int i = N - 1; i >= 0; i--) {
for (int j = 1; j <= Math.Sqrt(N); j++) {
if (i + j < N) {
dp[i] += arr[i + j];
}
}
}
}
static void QuerySum(int[] arr, int N, int[][] Q, int M)
{
for (int i = 0; i < M; i++) {
int x = Q[i][0];
int y = Q[i][1];
if (y <= Math.Sqrt(N)) {
int ans = 0;
for (int j = x; j < N; j += y) {
ans += arr[j];
}
Console.Write(ans + " ");
continue;
}
int sum = 0;
while (x < N) {
sum += arr[x];
x += y;
}
Console.Write(sum + " ");
}
}
static void Main(string[] args)
{
int[] arr = { 1, 2, 7, 5, 4 };
int[][] Q
= { new int[] { 2, 1 }, new int[] { 3, 2 } };
int N = arr.Length;
int M = Q.Length;
int[] dp = new int[N];
PrecomputeExpressionForAllVal(arr, N, dp);
QuerySum(arr, N, Q, M);
}
}
// This code is contributed by user_dtewbxkn77n
// JavaScript implementation of the above code
function precomputeExpressionForAllVal(arr, N) {
const dp = new Array(N).fill(0);
for (let i = N - 1; i >= 0; i--) {
for (let j = 1; j <= Math.sqrt(N); j++) {
if (i + j < N) {
dp[i] += arr[i + j];
}
}
}
return dp;
}
function querySum(arr, N, Q, M) {
for (let i = 0; i < M; i++) {
const x = Q[i][0];
const y = Q[i][1];
if (y <= Math.sqrt(N)) {
let ans = 0;
for (let j = x; j < N; j += y) {
ans += arr[j];
}
console.log(ans + " ");
continue;
}
let sum = 0;
while (x < N) {
sum += arr[x];
x += y;
}
console.log(sum + " ");
}
}
const arr = [1, 2, 7, 5, 4];
const Q = [
[2, 1],
[3, 2]
];
const N = arr.length;
const M = Q.length;
const dp = precomputeExpressionForAllVal(arr, N);
querySum(arr, N, Q, M);
Output:
16 5
Time complexity: O(N * sqrt(N) + |Q| * sqrt(N))
Auxiliary Space: O(N)
Similar Reads
Queries to calculate the Sum of Array elements in the range [L, R] having indices as multiple of K Given an array arr[] consisting of N integers, and a matrix Q[][] consisting of queries of the form (L, R, K), the task for each query is to calculate the sum of array elements from the range [L, R] which are present at indices(0- based indexing) which are multiples of K and Examples: Input: arr[]={
13 min read
Queries to calculate sum of the path from root to a given node in given Binary Tree Given an infinite complete binary tree rooted at node 1, where every ith node has two children, with values 2 * i and 2 * (i + 1). Given another array arr[] consisting of N positive integers, the task for each array element arr[i] is to find the sum of the node values that occur in a path from the r
10 min read
Queries to calculate sum of squares of array elements over range of indices [L, R] with updates Given an Array arr[] of positive integers of size n. We are required to perform following 3 queries on given array - 1) Given L and R, we have to find the sum of squares of all element lying in range [L,R] 2) Given L, R and X, we have to set all element lying in range [L,R] to X 3) Given L, R and X,
15+ min read
Index of the elements which are equal to the sum of all succeeding elements Given an array arr[] of N positive integers. The task is to find the index of the elements which are equal to the sum of all succeeding elements. If no such element exists then print -1.Examples: Input: arr[] = { 36, 2, 17, 6, 6, 5 } Output: 0 2 arr[0] = arr[1] + arr[2] + arr[3] + arr[4] + arr[5] ar
9 min read
Index of the elements which are equal to the sum of all succeeding elements Given an array arr[] of N positive integers. The task is to find the index of the elements which are equal to the sum of all succeeding elements. If no such element exists then print -1.Examples: Input: arr[] = { 36, 2, 17, 6, 6, 5 } Output: 0 2 arr[0] = arr[1] + arr[2] + arr[3] + arr[4] + arr[5] ar
9 min read
Queries to find minimum sum of array elements from either end of an array Given an array arr[] consisting of N distinct integers and an array queries[] consisting of Q queries, the task is for each query is to find queries[i] in the array and calculate the minimum of sum of array elements from the start and end of the array up to queries[i]. Examples: Input: arr[] = {2, 3
12 min read