给定一个整数数组 nums，求出数组从索引 i 到 j（i ≤ j）范围内元素的总和，包含 i、j 两点。

    实现 NumArray 类：

    NumArray(int[] nums) 使用数组 nums 初始化对象
    int sumRange(int i, int j) 返回数组 nums 从索引 i 到 j（i ≤ j）范围内元素的总和，包含 i、j 两点（也就是 sum(nums[i], nums[i + 1], … , nums[j])）

    示例：

    1. 输入：
    2. ["NumArray", "sumRange", "sumRange", "sumRange"]
    3. [[[-2, 0, 3, -5, 2, -1]], [0, 2], [2, 5], [0, 5]]
    4. 输出：
    5. [null, 1, -1, -3]
    7. 解释：
    8. NumArray numArray = new NumArray([-2, 0, 3, -5, 2, -1]);
    9. numArray.sumRange(0, 2); // return 1 ((-2) + 0 + 3)
    10. numArray.sumRange(2, 5); // return -1 (3 + (-5) + 2 + (-1)) 
    11. numArray.sumRange(0, 5); // return -3 ((-2) + 0 + 3 + (-5) + 2 + (-1))

    题解：

    这题提风明显， 初始化一个数组，并计算当前的数值和，最简单的做法就是数组赋值，并通过循环将值算出来，这种做法的时间复杂度为O(n),空间复杂度也为O(n)，所以要想大批量的调用不太方便

    可以想到，当第[i, j]的输入的时候，只需要知道[0, j]的总和跟[0, i]的总和，就能得出[i, j]的总和，所以可以得知，在初始化的时候直接计算每个数的总和，调用sumRange的时候，直接相减即可得到

    1. /**
    2.  * @param {number[]} nums
    3.  */
    4. var NumArray = function(nums) {
    5.     this.sums = [0];
    6.     for (let i = 0; i < nums.length; i++) {
    7.         this.sums[i + 1] = this.sums[i] + nums[i];
    8.     }
    9. };
    11. /** 
    12.  * @param {number} i 
    13.  * @param {number} j
    14.  * @return {number}
    15.  */
    16. NumArray.prototype.sumRange = function(i, j) {
    17.     return this.sums[j + 1] - this.sums[i];
    18. };
    20. /**
    21.  * Your NumArray object will be instantiated and called as such:
    22.  * var obj = new NumArray(nums)
    23.  * var param_1 = obj.sumRange(i,j)
    24.  */