Returns a continuous subsequence to maximize the sum (deformation)

An old question in programming: An array that finds continuous subsequences to maximize the sum. We can use the linear scanning algorithm to solve this problem. After this problem is transformed, it becomes: finding continuous subsequences so that they are closest to a certain number. The original time complexity is linear. We can accumulate an array, sort it, and calculate the adjacent difference. The number closest to k is what we want. The Code is as follows:

1. IntApproximate (Int* PArry,IntLen)
2. {
3. Int* Cum = 0;
4. Int* Realarry =New Int[Len + 1];
5. Realarry [0] = 0;
6. Cum = realarry + 1; // cum [-1] = 0
8. // Accumulate and store the sum of pArry [0... I] In cum [I]
9. For(IntI = 0; I <len; I ++)
10. {
11. Cum [I] = cum [I-1] + pArry [I];
12. }
13. Sort (cum, cum + len); // sorts cum
14. IntIMin = cum [1]-cum [0];
15. For(IntK = 1; k <len; k ++)
16. {
17. IMin = min (iMin, cum [k]-cum [k-1]); // returns the smallest difference between two adjacent elements.
18. }
19. ReturnIMin;
20. }