# Range sum query- Immutable array

Write a service which given an integer array, returns the sum of the elements between indices i and j (i ≤ j), inclusive. Example: nums = [-2, 0, 3, -5, 2, -1]
sumRange(0, 2) -> 1

sumRange(2, 5) -> -1

sumRange(0, 5) -> -3

Also, the input set does not change during the calls to the sumRange(i,j).

The brute force solution is to calculate the sum of all the elements A[i] to A[j] whenever a sumRange(i,j) is called. This method has time complexity of O(n). It is OK to have this solution for small scale but as the number of queries goes up, processing of all the numbers from `i` to `j` would be inefficient. Also, imagine a case where the array itself is very large, then `O(n)`

complexity for each query will lead to choking of your service.

## Range sum query- Immutable array : thoughts

There are two hints for optimization is in the question, first, the array is immutable, it does not change. Second, we have to build a service, that means we have a server with us. These two things allow us to pre-compute and store results even before the query is made.

Now, the question is what do we pre-compute and how do we store it? We can precompute the sum of all the elements between each `i` and `j` and store them in a two-dimensional array. `range[i][j]` stores the sum of all the elements between index `i` and `j`. It will use `O(n`

additional memory, however, the response time for each sumRange query will be constant. Also, the preprocessing step is ^{2})`O(n`

^{2})

Can we optimize for space as well? If I know the sum of all the elements from index 0 to index i and sum of all the elements from 0 to j, can I find the sum of all the elements between i and j? Of course, we can do it.

Sum(i,j) = Sum(0,j) - Sum(0,i) + A[i].

Below diagram explains it.

However, integer array is not passed in the query request, we cannot use it while calculating the sum. Instead, we will use formula like: Sum(i,j) = Sum(0,j) – Sum(0,i-1), which is equivalent to the above.

We will pre-calculate the sum of all the elements between index 0 and j for all j>=0 and j

class NumArray { int[] rangeSum; public NumArray(int[] nums) { rangeSum = new int[nums.length]; if(nums.length>0){ rangeSum[0] = nums[0]; for(int i=1; i<nums.length; i++){ rangeSum[i] = rangeSum[i-1] + nums[i]; } } } public int sumRange(int i, int j) { if(i==0) return rangeSum[j]; return rangeSum[j] - rangeSum[i-1]; } }

Now, the preprocessing step is `O(n)`

. `N` additional space is used. At the same time query response time is `O(1)`

.

Please share if there is anything wrong or missing in the post. If you are preparing for an interview and needs coaching to prepare for it, please book a free demo session with us.