# Background

Imagine, you have a big array `A`, which is mostly zeroes, but contains a short subarray `B` which has only strictly positive entries. For instance:

    |              B              |
    [0   0   0   0   1   2   3   0]
                   |     A     | 

Now say, we split the array `B` into consecutive subarrays of length `d` (with a shorter final array, if the `d` doesn't divide the length of `B`). For `d = 3`:

    [0   0   0   0   1   2   3   0]
               |           |
    [0   0   0] [0   1   2] [3   0]

And now sum up each of those arrays:

    [0 3 3]

And discard zero sums:

    [3 3]

# The Challenge

You're to write a function which prints that final array of sums in any convenient array format, given the following 5 parameters (or any subset thereof, if you don't need all of them):

- The small array `B`.
- The size of the small array `B` (`3` in the above example).
- The *size* of the big array `A` (`8` in the above example).
- The index where the small array begins (`4` in the above example).
- The length `d` of the subarrays (`3` in the above example).

# The Rules

- You are not allowed to construct the big array `A` explicitly!
- You are not allowed to construct any of the subarrays of length `d` explicitly!
- That means you have to get the computation directly from the `B` and the other parameters at your disposal!

Fewest characters wins!