Shortest program to split special array 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:

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


Now say, we split the array A into consecutive subarrays of length d (with a shorter final array, if the d doesn't divide the length of A). 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!
CJam, 34 32 28 characters
{&quot;ɚ광䃻噣攍圍숵셳ﶓ訙➰鑓쥾&quot;2G#b126b:c~}

This is a compressed form of the following 31 bytes solution
{:D%0a*\+0\{+U):UD={0:U}*}%0-p}

This can be golfed further.
Try it online here
Input is in format of [small_array] index_where_small_array_begins divisor
For example:
[1 2 3] 5 3{&quot;ɚ광䃻噣攍圍숵셳ﶓ訙➰鑓쥾&quot;2G#b126b:c~}~

will give output
[1 5]

Explanation (outdated):
{                                   &quot;Begin of function block&quot;;
 :D                                 &quot;Store the divisor in D&quot;;
   %                                &quot;Calculate index_where_small_array_begins%divisor&quot;;
    0a*                             &quot;Get an array of 0 on length above number&quot;;
       \+                           &quot;Prepend it to the small_array&quot;;
         _,{            }*          &quot;Run this code block length(small_array) times&quot;;
            0\                      &quot;Put 0 before small_array. This 0 marks the&quot;
                                    &quot;current sum of the current mini_array&quot;;
              {      }D*            &quot;Run this code block divisor times&quot;;
               0+                   &quot;Add 0 at the end of mini array&quot;;
                 (                  &quot;Take out the first element from the mini array&quot;;
                  @                 &quot;Rotate the stack to get current sum on top&quot;;
                   +                &quot;Add the first element to the current sum&quot;;
                    \               &quot;Swap to put current mini_array on top of stack&quot;;
                          ;]        &quot;Pop the residual array and wrap the sums in an array&quot;;
                            0-p     &quot;Remove 0 and print the sum_of_mini_arrays_array&quot;;
                               }    &quot;End of function block&quot;;