Given an array arr of integers of size n. We need to compute the sum of elements from index i to index j. The queries consisting of i and j index values will be executed multiple times.
Examples:
Input : arr[] = {1, 2, 3, 4, 5}
i = 1, j = 3
i = 2, j = 4
Output : 9
12
Input : arr[] = {1, 2, 3, 4, 5}
i = 0, j = 4
i = 1, j = 2
Output : 15
5
A Simple Solution is to compute the sum for every query.
Below is the implementation of the above approach:
// C++ program to find sum between two indexes // when there is no update. #include <bits/stdc++.h> using namespace std;
// Function to compute sum in given range int rangeSum( int arr[], int n, int i, int j) {
int sum = 0;
// Compute sum from i to j
for ( int k = i; k <= j; k++) {
sum += arr[k];
}
return sum;
} // Driver code int main() {
int arr[] = { 1, 2, 3, 4, 5 };
int n = sizeof (arr) / sizeof (arr[0]);
// Function call with queries
cout << rangeSum(arr, n, 1, 3) << endl;
cout << rangeSum(arr, n, 2, 4) << endl;
return 0;
} |
public class Main {
// Function to compute sum in given range
static int rangeSum( int [] arr, int i, int j) {
int sum = 0 ;
// Compute sum from i to j
for ( int k = i; k <= j; k++) {
sum += arr[k];
}
return sum;
}
// Driver code
public static void main(String[] args) {
int [] arr = { 1 , 2 , 3 , 4 , 5 };
int n = arr.length;
// Function call with queries
System.out.println(rangeSum(arr, 1 , 3 ));
System.out.println(rangeSum(arr, 2 , 4 ));
}
} |
# Python3 program to find sum between two indexes # when there is no update. # Function to compute sum in given range def rangeSum(arr, n, i, j) :
sum = 0 ;
# Compute sum from i to j
for k in range (i, j + 1 ) :
sum + = arr[k];
return sum ;
# Driver code if __name__ = = "__main__" :
arr = [ 1 , 2 , 3 , 4 , 5 ];
n = len (arr);
# Function call with queries
print (rangeSum(arr, n, 1 , 3 ));
print (rangeSum(arr, n, 2 , 4 ));
# This code is contributed by ankthon
|
using System;
public class RangeSumCalculator
{ // Function to compute sum in the given range
public static int RangeSum( int [] arr, int i, int j)
{
int sum = 0;
// Compute sum from index i to j
for ( int k = i; k <= j; k++)
{
sum += arr[k];
}
return sum;
}
public static void Main( string [] args)
{
int [] arr = { 1, 2, 3, 4, 5 };
int n = arr.Length;
// Function calls with queries
Console.WriteLine(RangeSum(arr, 1, 3));
Console.WriteLine(RangeSum(arr, 2, 4));
}
} |
function GFG(arr, i, j) {
let sum = 0;
// Compute sum from i to j
for (let k = i; k <= j; k++) {
sum += arr[k];
}
return sum;
} // Driver code function main() {
const arr = [1, 2, 3, 4, 5];
const n = arr.length;
// Function call with queries
console.log(GFG(arr, 1, 3));
console.log(GFG(arr, 2, 4));
} // Invoke the main function main(); |
Output
9
12
Time Complexity: For each query, the time complexity will be O(j-i+1). The overall time complexity is O((j-i+1) * q), where q is the number of queries.
Space Complexity: O(1), not using any extra space.
An Efficient Solution is to precompute prefix sum. Let pre[i] stores sum of elements from arr[0] to arr[i]. To answer a query (i, j), we return pre[j] – pre[i-1].
Below is the implementation of the above approach:
// CPP program to find sum between two indexes // when there is no update. #include <bits/stdc++.h> using namespace std;
void preCompute( int arr[], int n, int pre[])
{ pre[0] = arr[0];
for ( int i = 1; i < n; i++)
pre[i] = arr[i] + pre[i - 1];
} // Returns sum of elements in arr[i..j] // It is assumed that i <= j int rangeSum( int i, int j, int pre[])
{ if (i == 0)
return pre[j];
return pre[j] - pre[i - 1];
} // Driver code int main()
{ int arr[] = { 1, 2, 3, 4, 5 };
int n = sizeof (arr) / sizeof (arr[0]);
int pre[n];
// Function call
preCompute(arr, n, pre);
cout << rangeSum(1, 3, pre) << endl;
cout << rangeSum(2, 4, pre) << endl;
return 0;
} |
// Java program to find sum between two indexes // when there is no update. import java.util.*;
import java.lang.*;
class GFG {
public static void preCompute( int arr[], int n,
int pre[])
{
pre[ 0 ] = arr[ 0 ];
for ( int i = 1 ; i < n; i++)
pre[i] = arr[i] + pre[i - 1 ];
}
// Returns sum of elements in arr[i..j]
// It is assumed that i <= j
public static int rangeSum( int i, int j, int pre[])
{
if (i == 0 )
return pre[j];
return pre[j] - pre[i - 1 ];
}
// Driver code
public static void main(String[] args)
{
int arr[] = { 1 , 2 , 3 , 4 , 5 };
int n = arr.length;
int pre[] = new int [n];
preCompute(arr, n, pre);
System.out.println(rangeSum( 1 , 3 , pre));
System.out.println(rangeSum( 2 , 4 , pre));
}
} // Code Contributed by Mohit Gupta_OMG <(0_o)> |
# Python program to find sum between two indexes # when there is no update. # Function to compute prefix sum def preCompute(arr, n, prefix):
prefix[ 0 ] = arr[ 0 ]
for i in range ( 1 , n):
prefix[i] = prefix[i - 1 ] + arr[i]
# Returns sum of elements in arr[i..j] # It is assumed that i <= j def rangeSum(l, r):
if l = = 0 :
print (prefix[r])
return
print (prefix[r] - prefix[l - 1 ])
# Driver code arr = [ 1 , 2 , 3 , 4 , 5 ]
n = len (arr)
prefix = [ 0 for i in range (n)]
# preComputation preCompute(arr, n, prefix) # Range Queries rangeSum( 1 , 3 )
rangeSum( 2 , 4 )
# This code is contributed by dineshdkda31. |
// Program to find sum between two // indexes when there is no update. using System;
class GFG {
public static void preCompute( int [] arr, int n,
int [] pre)
{
pre[0] = arr[0];
for ( int i = 1; i < n; i++)
pre[i] = arr[i] + pre[i - 1];
}
// Returns sum of elements in
// arr[i..j]
// It is assumed that i <= j
public static int rangeSum( int i, int j, int [] pre)
{
if (i == 0)
return pre[j];
return pre[j] - pre[i - 1];
}
// Driver code
public static void Main()
{
int [] arr = { 1, 2, 3, 4, 5 };
int n = arr.Length;
int [] pre = new int [n];
// Function call
preCompute(arr, n, pre);
Console.WriteLine(rangeSum(1, 3, pre));
Console.WriteLine(rangeSum(2, 4, pre));
}
} // Code Contributed by Anant Agarwal. |
<script> // JavaScript Program to find sum between two // indexes when there is no update. let pre = new Array(1000,0);
function preCompute(arr, n)
{ pre[0] = arr[0];
for (let i = 1; i < n; i++)
pre[i] = arr[i] + pre[i - 1];
} // Returns sum of elements in // arr[i..j] // It is assumed that i <= j function rangeSum(i, j, pre)
{ if (i == 0)
return pre[j];
return pre[j] - pre[i - 1];
} // Driver code let arr = [1, 2, 3, 4, 5]; let n = arr.length; // Function call preCompute(arr, n); document.write(rangeSum(1, 3, pre)+ "<br>" );
document.write(rangeSum(2, 4, pre)); </script> |
9 12
Here time complexity of every range sum query is O(1) and the overall time complexity is O(n).
Auxiliary Space required = O(n), where n is the size of the given array.
The question becomes complicated when updates are also allowed. In such situations when using advanced data structures like Segment Tree or Binary Indexed Tree.
This article is contributed by <Rahul Chawla.