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
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
Sum of all array elements less than X and greater than Y for Q queries Given a sorted array arr[], and a set Q having M queries, where each query has values X and Y, the task is to find the sum of all integers less than X and greater than Y present in the array. Note: X and Y may or may not be present in the array. Examples: Input: arr[] = [3 5 8 12 15], Q = {{5, 12},
9 min read
Queries to count sum of rows and columns of a Matrix present in given ranges Given a matrix A[][] of size N * M and a 2D array queries[][] consisting of Q queries of the form {L, R}, the task is to count the number of row-sums and column-sums which are an integer from the range [L, R]. Examples: Input: N = 2, M = 2, A[][] = {{1, 4}, {2, 5}}, Q = 2, queries[][] = {{3, 7}, {3,
14 min read
Minimum count of indices to be skipped for every index of Array to keep sum till that index at most T Given an array, arr[] of size N and an integer T. The task is to find for each index the minimum number of indices that should be skipped if the sum till the ith index should not exceed T. Examples: Input: N = 7, T = 15, arr[] = {1, 2, 3, 4, 5, 6, 7}Output: 0 0 0 0 0 2 3 Explanation: No indices need
8 min read
Count of elements which is the sum of a subarray of the given Array Given an array arr[], the task is to count elements in an array such that there exists a subarray whose sum is equal to this element.Note: Length of subarray must be greater than 1. Examples: Input: arr[] = {1, 2, 3, 4, 5, 6, 7} Output: 4 Explanation: There are 4 such elements in array - arr[2] = 3
7 min read
Print modified array after performing queries to add (i - L + 1) to each element present in the range [L, R] Given an array arr[] consisting of N 0s (1-based indexing) and another array query[], with each row of the form {L, R}, the task for each query (L, R) is to add a value of (i - L + 1) over the range [L, R] and print the array arr[] obtained after performing all the queries. Examples: Input: arr[] =
13 min read
Find sum of all unique elements in the array for K queries Given an arrays arr[] in which initially all elements are 0 and another array Q[][] containing K queries where every query represents a range [L, R], the task is to add 1 to each subarrays where each subarray is defined by the range [L, R], and return sum of all unique elements.Note: One-based index
8 min read