---
title: '303. Range Sum Query - Immutable'
description: Given an integer array nums, handle multiple queries of the following type
icon: dot
topics:
  - { name: "Array", slug: "array" }
  - { name: "Design", slug: "design" }
  - { name: "Prefix Sum", slug: "prefix-sum" }
video: "2pndAmo_sMA"
issue: "https://github.com/prdlk/leetcode/issues/36"
sidebar:
  label: 'Range Sum Query - Immutable'
  badge: 'Easy'
---

### Example 1:
- Input: `["NumArray", "sumRange", "sumRange", "sumRange"]` `[[[-2, 0, 3, -5, 2, -1]], [0, 2], [2, 5], [0, 5]]`
- Output: `[null, 1, -1, -3]`
- Explanation: `NumArray numArray = new NumArray([-2, 0, 3, -5, 2, -1]);` `numArray.sumRange(0, 2); // return (-2) + 0 + 3 = 1` `numArray.sumRange(2, 5); // return 3 + (-5) + 2 + (-1) = -1` `numArray.sumRange(0, 5); // return (-2) + 0 + 3 + (-5) + 2 + (-1) = -3`

### Constraints:

- `1 <= nums.length <= 10^4`
- `-10^5 <= nums[i] <= 10^5`
- `0 <= left <= right < nums.length`
- At most `10^4` calls will be made to `sumRange`.

## Approach

```mermaid
flowchart TD
  subgraph build["constructor(nums) — O(n) once"]
    A["prefix = [0]"] --> B{"more n in nums?"}
    B -- yes --> C["prefix.push(last + n)"]
    C --> B
  end
  build --> Q
  subgraph Q["sumRange(left, right) — O(1) per call"]
    D(["return prefix[right + 1] - prefix[left]"])
  end
```

## Solution

```js
/**
 * @param {number[]} nums
 */
class NumArray {
    constructor(nums) {
      this.prefix = [0];
      for (let n of nums){
        this.prefix.push(this.prefix[this.prefix.length - 1] + n);
      }
    }
    /**
     * @param {number} left
     * @param {number} right
     * @return {number}
     */
    sumRange(left, right) {
        return this.prefix[right + 1] - this.prefix[left];
    }
}


/** 
 * Your NumArray object will be instantiated and called as such:
 * var obj = new NumArray(nums)
 * var param_1 = obj.sumRange(left,right)
 */
```