<p>You are given the array <code>nums</code> consisting of <code>n</code> positive integers. You computed the sum of all non-empty continuous subarrays from the array and then sorted them in non-decreasing order, creating a new array of <code>n * (n + 1) / 2</code> numbers.</p>

<p><em>Return the sum of the numbers from index </em><code>left</code><em> to index </em><code>right</code> (<strong>indexed from 1</strong>)<em>, inclusive, in the new array. </em>Since the answer can be a huge number return it modulo <code>10<sup>9</sup> + 7</code>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> nums = [1,2,3,4], n = 4, left = 1, right = 5
<strong>Output:</strong> 13 
<strong>Explanation:</strong> All subarray sums are 1, 3, 6, 10, 2, 5, 9, 3, 7, 4. After sorting them in non-decreasing order we have the new array [1, 2, 3, 3, 4, 5, 6, 7, 9, 10]. The sum of the numbers from index le = 1 to ri = 5 is 1 + 2 + 3 + 3 + 4 = 13. 
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> nums = [1,2,3,4], n = 4, left = 3, right = 4
<strong>Output:</strong> 6
<strong>Explanation:</strong> The given array is the same as example 1. We have the new array [1, 2, 3, 3, 4, 5, 6, 7, 9, 10]. The sum of the numbers from index le = 3 to ri = 4 is 3 + 3 = 6.
</pre>

<p><strong class="example">Example 3:</strong></p>

<pre>
<strong>Input:</strong> nums = [1,2,3,4], n = 4, left = 1, right = 10
<strong>Output:</strong> 50
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>n == nums.length</code></li>
	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
	<li><code>1 &lt;= nums[i] &lt;= 100</code></li>
	<li><code>1 &lt;= left &lt;= right &lt;= n * (n + 1) / 2</code></li>
</ul>

import heapq

class Solution:

    result = []
    thedict = dict()
    theheap = []

    def add_num(self, num):
        if num not in self.thedict:
            self.thedict[num] = 0
            heapq.heappush(self.theheap, num)
        self.thedict[num] += 1

    def calculate(self, nums, p = 0):
        self.result.append([])
        if p == len(nums) - 1:
            self.result[p].append(nums[p])
            self.add_num(nums[p])
        else:
            self.calculate(nums, p + 1)
            next_res = self.result[p + 1]
            self.add_num(nums[p])
            self.result[p].append(nums[p])
            for tmpnum in next_res:
                self.result[p].append(nums[p] + tmpnum)
                self.add_num(nums[p] + tmpnum)
            


    def rangeSum(self, nums: List[int], n: int, left: int, right: int) -> int:
        self.thedict = dict()
        self.result = []
        self.theheap = []

        self.calculate(nums)
        # print(right)
        # print(self.thedict)
        # print(self.result)
        # print(self.theheap)
        # print(right)

        p = 0
        theans = 0
        
        # right -= 1
        left -= 1
        # print(right)
        while p < right:
            num = heapq.heappop(self.theheap)
            p_add = self.thedict[num]
            next_p = p + p_add
            end = min(right, next_p)
            start = max(left, p)

            cal_count = max(end - start, 0)
            # print(p, num, cal_count, end, start, right, next_p)
            theans += num * cal_count
            theans = theans%(10**9 + 7)
            p = next_p
        return theans
        
41457