Add an array with itself

Question

Your challenge today is to take an array, split it into chunks, and add those chunks.

Here's how this works: Your program or function will be given an array of integers a and a chunk size L. The array should be split into arrays of size L, if the array length is not divisible by L then the array should have 0's appended to it so that it is evenly divisible. Once the array is chunked, all chunks are to be added together element-wise. The resulting array is then output.

You can assume L is greater than 0, and that a is nonempty. You cannot make the assumption that a's contents are positive.

Here's an example:

[1,2,3,4,5,6,7,8], 3 => [1,2,3]+[4,5,6]+[7,8,0] =>  [1+4+7,2+5+8,3+6+0] => [12,15,9]

Test cases:

Array                           Length   Output
[1]                             1        [1]
[1]                             3        [1,0,0]
[0]                             3        [0,0,0]
[1,2]                           3        [1,2,0]
[1,2]                           1        [3]
[-1,1]                          2        [-1,1]
[-7,4,-12,1,5,-3,12,0,14,-2]    4        [12,-1,0,1]
[1,2,3,4,5,6,7,8,9]             3        [12,15,18]

This is code-golf, fewest bytes wins!

Answer 1

Python 3, 67 65 42 bytes

Uses the fact that the sum of an empty array is 0

lambda x,y:[sum(x[i::y])for i in range(y)]

Try it online!

Answer 2

MATL, 4 bytes

e!Xs

Try it online!

First bit of MATL code I've written! Takes two inputs, a as a row vector (comma-separated) and l as a number. Works out to be

e          # reshape `a` into `l` rows (auto pads with 0)
 !         # transpose
  Xs       # sum down the columns

Answer 3

Jelly, 7 6 bytes

1 byte thanks to Dennis.

;0$¡sS

Try it online!

Answer 4

Mathematica, 27 bytes

^{Mathematica almost had a builtin for this}

Total@Partition[##,#2,1,0]&

Try it on Wolfram Sandbox

Usage

Total@Partition[##,#2,1,0]&[{-7, 4, -12, 1, 5, -3, 12, 0, 14, -2}, 4]

{12, -1, 0, 1}

Explanation

Total@Partition[##,#2,1,0]&
      
      Partition[##,#2,1,0]   (* Partition the first input into sublists of length
                                second input, using offset second input, and
                                right-pad zeroes for incomplete partitions *)
Total@                       (* Add all *)

Answer 5

Python 2, 49 bytes

lambda x,n:map(sum,zip(*zip(*[iter(x+n*[0])]*n)))

Try it online!

Answer 6

JavaScript (ES6), 51 bytes

a=>n=>a.map((v,i)=>o[i%n]+=v,o=Array(n).fill(0))&&o

Takes input in currying syntax: f([1,2])(3).

Test Cases

let f=
a=>n=>a.map((v,i)=>o[i%n]+=v,o=Array(n).fill(0))&&o

;[[[1], 1], [[1], 3], [[0], 3], [[1,2], 3], [[1,2], 1], [[-1,1], 2], [[-7,4,-12,1,5,-3,12,0,14,-2], 4], [[1,2,3,4,5,6,7,8,9], 3]]
.forEach(([A,N])=>console.log(`${JSON.stringify(A)}, ${N} -> ${f(A)(N)}`))

.as-console-wrapper{max-height:100%!important}

Answer 7

Mathematica, 58 bytes

Total@Partition[PadRight[#,(s=Length@#)+Mod[-s,#2]],{#2}]&

Input

[{1},3]

Output

{1,0,0}

Answer 8

Java 7, 86 bytes

No fancy folds or matrices, just a good ol' fashioned for loop :)

int[]o(int[]a,int l){int i=0,o[]=new int[l];for(;i<a.length;)o[i%l]+=a[i++];return o;}

Try it on Ideone

Lined:

int[]o(int[]a,int l){
    int i=0,
        o[]=new int[l];
    for(;i<a.length;)
        o[i%l]+=a[i++];
    return o;
}

Answer 9

Husk, 9 bytes

S↑ȯ¡¬Fż+C

Try it online!

Explanation

        C    Cut into lists of length n
     Fż+     Sum them element-wise
  ȯ¡¬        Append infinitely many 0s
S↑           Take the first n elements

Answer 10

Perl 6, 36 bytes

{[Z+] flat(@^a,0 xx$^b*2).rotor($b)}

Test it

Expanded:

{  # bare block lambda with 2 placeholder parameters ｢@a｣, ｢$b｣
  [Z+]
    flat(
      @^a,         # declare and use the first parameter
      0 xx $^b * 2 # 0 list repeated 2 * the second parameter
    )
    .rotor($b)     # split into chunks that are the size of the second param
}

[1,2], 3

( [1,2], (0,0,0,0,0,0) ) # @^a,0 xx$^b*2
(1,2,0,0,0,0,0,0)        # flat(…)
( (1,2,0), (0,0,0) )     # .rotor($b) # (drops partial lists)
(1,2,0)                  # [Z+]

Answer 11

BQN, 8 bytes^SBCS

+˝↑˙⊸⋈⊸⥊

Run online!

{+˝↑‿𝕩⥊𝕨} is 1 longer. BQN's reshape is very good.

Answer 12

APL (Dyalog), 22 bytes

Takes l as left argument and a a right argument.

{+⌿s⍴⍵↑⍨×/s←⍺,⍨⌈⍺÷⍨≢⍵}

Try it online!

{…} anonymous function where ⍺ is the left argument (l) and ⍵ the right argument (a).

 ≢⍵ tally (length) of a

 ⍺÷⍨ divide by l

 ⌈ ceiling (round up)

 ⍺,⍨ append l

 s← store in s (for shape)

 ×/ product of that (i.e. how many integers are needed)

 ⍵↑⍨ take that many integers from a (padding with zeros)

 s⍴ reshape to shape s (rows, columns)

 +⌿ columnar sums

Answer 13

Haskell, 59 49 bytes

a%l=[sum$map((0:a)!!)[i,l+i..length a]|i<-[1..l]]

Try it online!

Answer 14

Perl 6, 40 bytes

{[Z+] (|@^a,|(0 xx*)).rotor($^l)[0..@a]}

Try it online!

If you like the number 42, you can swap the * for an ∞. That will make it 42 bytes :—).

Explanation:

{[Z+] (|@^a,|(0 xx*)).rotor($^l)[0..@a]} The whole function
{                                      } Anonymous block
      (    ,        )                    List with 2 elements
        @^a                              The first argument (it is a list)
             (0 xx*)                     Infinite list of zeroes
       |    |                            Flatten both of the lists into the larger list.
                    .rotor($^l)          Split the list into a list of lists, each (the second argument) long.
                               [0..@a]   Only the first (1 + length of the first argument) of them.
 [Z+]                                    Add the corresponding elements up.

The magic behind the last "add up" is that the operator is a "reduce with zip with +". By the way, this would break down if we used it only on a list with 1 list inside, but that never happens if the original list was non-empty (due to the second-to-last row). Also note that we end up taking not only @a, but @a * $l items. Fortunately we added only zeroes which won't affect the final result.

Answer 15

Pyth, 8 bytes

m+F%Q>vz

Try it here!

Pyth, 10 bytes

sMCc.[EZQQ

Try it here!

Explanation

Explanation #1

m+F%Q>vz   Full program. Q means input.

m          Map over the implicit range [0, input_1), with a variable d.
     >vz  All the elements of input_2 after d; input_2[d:] in Python.
   %Q     Every Qth element of ^.
 +F       Sum. Implicitly output the result.

Explanation #2

sMCc.[EZQQ   Full program.

    .[E      Pad the second input to the right, with repeated copies of...
       Z     ... Zero (0), up to the nearest multiple of...
        Q    ... The first input.
   c     Q   Chop into chunks of length equal to the first input.
  C          Matrix transpose. Get all the columns of the nested list.
sM           Sum each.
             Output (implicitly). 

Answer 16

J, 15 12 bytes

]{.+/@(]\~-)

Try it online!

Explanation

]{.+/@(]\~-)  Input: array A (LHS), chunk size L (RHS)
          -   Negate L
       ]\~    Take each non-overlapping sublist of size L in A
   +/@        Reduce the columns by addition
]             Get L
 {.           Take that many, filling with 0's

Answer 17

R, 62 57 bytes

-5 bytes thanks to user2390246

function(a,l)rowSums(matrix(c(a,rep(0,l-sum(a|1)%%l)),l))

Try it online!

Updated since it no longer has to handle the empty case.

pads a with zeros, constructs a matrix of l rows, and computes and returns the row sums.

Answer 18

05AB1E, 8 bytes

ô0ζO²Å0+

Try it online!

ô0ζO²Å0+   Full program
ô          Push <1st input> split into a list of <2nd input> pieces
 0ζ        Zip sublists with 0 as a filler
   O       Sum each sublist
           --- from here, the program handles outputs shorter 
               than the required length
    ²Å0    Push a list of zeros of length <2nd input>
       +   Sum the result with that list

Answer 19

05AB1E, 8 bytes

Å0+¹ô0ζO

Try it online!

Å0       # Push an arrary of all 0s with length l
  +      # Add that to the array
   ¹ô    # Split into chunks of length l
     0ζ  # Zip, padding with 0s
       O # Sum each chunk

Answer 20

Vyxal, 7 bytes

ẇR∆ZR∩Ṡ

Try it Online!

Answer 21

SOGL V0.12, 14 bytes

l⁵%⁵κ{0+}nI⌡∑¹

Try it Here! or Try all the test-cases. this is written as an unnamed function and expects chunk length; array on the stack.

Explanation:

padding zeroes
l          get the array's length
 ⁵%        modulo the chunk length
   ⁵κ      chunk length - result of above
     {  }  that many times
      0+     append a 0 to the array

adding the array together
n      split into the chunks
 I     rotate clockwise
  ⌡    for each
   ∑     sum
    ¹  wrap the results in an array

Answer 22

05AB1E, 12 bytes

gs÷*+Å0¹+ôøO

Try it online!

Explanation

gs÷*+Å0¹+ôøO
g            # Get the length of the first input (the array)
 s           # Push the second input on top of the result
  ÷          # integer divide the two values
   *         # Multiply with the second input (the length)...
    +        # and add the second input to the result
     Å0      # Create a list of zeros with that length
       ¹+    # Add it to the first input
         ô   # And finally split it into chunks of the input length...
          ø  # ...transpose it...
           O # and sum each resulting subarray
             # Implicit print

   

Answer 23

Mathematica, 43 bytes

Plus@@#~ArrayReshape~{⌈Tr[1^#]/#2⌉,#2}&

Answer 24

Husk, 10 bytes

Fż+So:`R0C

Try it online!

Ungolfed/Explanation

             -- implicit inputs n & xs                   | 3  [1,2,3,4]
   S      C  -- cut xs into sublists of length n & ...   | [[1,2,3], [4]]
    (:`R0)   -- ... prepend [0,...,0] (length n)         | [[0,0,0], [1,2,3], [4]]
F            -- accumulate the sublists with             |
 ż+          -- element-wise addition                    | [0+1+4, 0+2, 0+3]

Answer 25

Clojure, 42 bytes

#(apply map +(partition %2 %2(repeat 0)%))

Try it online!

Answer 26

Jq 1.5, 31 bytes

[_nwise($n)]|transpose|map(add)

Sample Run

$ jq -Mc --argjson n 3 '[_nwise($n)]|transpose|map(add)' <<< "[1,2,3,4,5,6,7,8]"
[12,15,9]

Takes advantage of builtins: _nwise, transpose, add and map

Answer 27

Stacked, 24 bytes

[:@z#<[0 z rpad]map sum]

Try it online!

Explanation

[:@z#<[0 z rpad]map sum]
[                      ]   anonymous function
 :@z                       stores TOS as `z` (the length)
    #<                     cut STOS in TOS slices
      [        ]map        for each slice
       0 z rpad               pad the slice with `z` zeroes
                    sum]   summate all inner slices

Answer 28

Java (OpenJDK 8), 64 bytes

n->a->{int k=0,r[]=new int[n];for(int i:a)r[k++%n]+=i;return r;}

Try it online!

Answer 29

Japt, 7 bytes

Man, I fought with the wrong Japt method for far too long trying to get it to work for the [1], 3 test case in a reasonable amount of bytes!

VÆëVX x

Try it

---

Explanation

Implicit input of array U and integer V.

VÆ

Generate an array of integers from 0 to V-1 and pass each through a function with X being the current element.

ëVX

Grab every Vth element of U, beginning at index X.

x

Reduce that array by addition.

Answer 30

C, (GCC) 101 86 Bytes

Try it online!

f(int*a,int l,int s,int*m){if(s){int i=l;while(i&&s){m[l-i--]+=*a++;s--;}f(a,l,s,m);}}

Usage

int main() {
   int l = 3;
   int a[8] = {1,2,3,4,5,6,7,8};
   int *m = (int *)malloc(sizeof(int) * l);
   f(a, l, 8, m);
   for (int i=0; i<3; i++) {
    printf("%d, ",m[i]);
   }
}

Note that you have to pass in the length of the array (s) and a new dynamic array on the heap (m).