# 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]


[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!

• Can we remove/omit the inputs we don't need? As far as I can tell, I don't need size_bigarray or size_smallarray at all. – Geobits Nov 24 '14 at 16:00
• yes if you don't need it – nvidia Nov 24 '14 at 16:02
• May we construct the mini arrays that overlap with small_array? In your example, that would only be [0,1,2], 3,0]. Or none at all? – Martin Ender Nov 24 '14 at 16:09
• no mini arrays should be constructed – nvidia Nov 24 '14 at 16:14
• I tried to reword the spec a bit, to make the actual problem a bit more visual in the first place. Feel free to roll back the edit if you don't like it, it's just a suggestion! – Martin Ender Nov 25 '14 at 1:48

# 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";


# 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

• You can change *]0lG to m0G. – isaacg Nov 25 '14 at 3:42
• @isaacg Thanks, that's good to know :) – FryAmTheEggman Nov 25 '14 at 4:41
• @isaacg I've also noticed in a few recent problems that pyth kinda loses out in some golf problems because it doesn't automatically mod indexing by the length of the collection. I looked at the source code, and this doesn't look easy to change, but it might be a good idea ;) (you might also then be able to overload @ with something else... ;p ) – FryAmTheEggman Nov 25 '14 at 4:46
• The only issue would be that assigning to a list could no longer use the same character as a lookup. I'll take a look. – isaacg Nov 25 '14 at 5:11

# 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-216, 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 .";
*                       "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  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.";


# 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 ]