Shortest program to split special array

Question

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!

Answer 1

CJam, 34 32 28 characters

{"ɚ광䃻噣攍圍숵셳ﶓ訙➰鑓쥾"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{"ɚ광䃻噣攍圍숵셳ﶓ訙➰鑓쥾"2G#b126b:c~}~

will give output

[1 5]

Explanation (outdated):

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

Answer 2

Pyth - 30 32

Edit: Fixed an error with mini array size 1 or very large offset.

D:GHYKm0GFNG~@K%/HYlGN~H1)RfTK

Defines a function : that takes small_array, index_where_small_array_begins and divisor as arguments. You can call it like:

:[1 2 3) 5 3

Returns: [1, 5]

Try it online

Explanation:

D:GHY                            : Define :
     Km0G                        : Make K an array of len(G) zeroes
         FNG             )       : for N in small_array
            ~@K%/HYlGN           : Add N to K[floor_div(H,Y)%len(G)]
                      ~H1        : Increment H
                          RfTK   : Return K without any zeroes

Answer 3

CJam, 30 28 characters

{"ᘏ阋Յ꺂࠻䚉누୛伪"6e4b127b:c~}

(SE may have swallowed some unprintable characters. Please copy the code from this character counter.)

Yay for counting by characters and Unicode packing. The above string is converted to character codes, interpreted as base-2¹⁶, converted to base-129, and converted back to characters, and evaluated, to give the actual code (measuring 30 bytes):

{:M%0a*\+{0\{_0a?(@+\}M*}h;]p}

This is a block, the closest thing to a function in CJam. It expects the small array, the offset, and the divisor on the stack. You can use it like

[1 2 3]4 3{"    ড숺ꤪ洽ὦ﮻ڤ綃掖迓湯"2G#b129b:c~}~

Test it here.

Explanation

:M                           "Store divisor in M.";
  %                          "Take offset modulo divisor to get R.";
   0a                        "Push [0].";
     *                       "Repeat to get R zeros.";
      \+                     "Preprend to small array.";
        {              }h    "Repeat while... leaves condition on the stack.";
         0\                  "Put a 0 underneath the array to initialise sum.";
           {        }M*      "Run the block M times.";
            _0a?             "Replace the list by [0] if it's empty.";
                (            "Split off first element.";
                 @           "Pull up current sum.";
                  +\         "And and pull list back to the top.";
                         ;   "Remove leftover empty list.";
                          ]  "Wrap sums in array.";
                           p "Print string representation to STDOUT."; 

Answer 4

JavaScript (ES6) 58

Function with 3 parameters
- b is the small array
- i is the index where the small array begins
- d is the dimension of the subarrays

(t is used just as a local variable)

 F=(b,i,d,t=[])=>b.map((v,p)=>t[p=(p+i%d)/d|0]=v+~~t[p])&&t

Test In FireFox/FireBug console

F([1,2,3],4,3)

Output

[ 3, 3 ]