# Range sum queries without updates

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 = 4Output :  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++14

 `// C++ program to find sum between two indexes``// when there is no update.``#include ``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;``}`

## Java

 `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

 `# 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`

## C#

 `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));``    ``}``}`

## Javascript

 `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

`912`

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:

## C++

 `// CPP program to find sum between two indexes``// when there is no update.``#include ``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

 `// 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)>`

## Python3

 `# 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.`

## C#

 `// 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.`

## Javascript

 ``

Output
```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.