Su desafío hoy es tomar una matriz, dividirla en trozos y agregar esos trozos.

Así es como funciona: su programa o función recibirá una variedad de enteros ay un tamaño de fragmento L. La matriz debe dividirse en matrices de tamaño L, si la longitud de la matriz no es divisible para Lentonces, la matriz debe tener 0 añadidos para que sea divisible de manera uniforme. Una vez que la matriz está fragmentada, todas las fragmentaciones deben agregarse juntas por elementos. La matriz resultante se emite a continuación.

Puede suponer que Les mayor que 0, y eso ano es vacío. No se puede suponer que alos contenidos son positivos.

Aquí hay un ejemplo:

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

Casos de prueba:

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]

Este es el código de golf , ¡la menor cantidad de bytes gana!

MATL , 4 bytes

e!Xs

Pruébalo en línea!

¡El primer bit de código MATL que he escrito! Toma dos entradas, acomo un vector de fila (separadas por comas) y lcomo un número. Funciona para ser

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

Python 3 , 67 65 42 bytes

Utiliza el hecho de que la suma de una matriz vacía es 0

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

Pruébalo en línea!

Jalea , 7 6 bytes

1 byte gracias a Dennis.

;0$¡sS

Pruébalo en línea!

Java 7, 86 bytes

Sin pliegues ni matrices elegantes, solo un buen forbucle antiguo :)

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

Pruébalo en Ideone

Forrado:

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

Python 2 , 49 bytes

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

Pruébalo en línea!

JavaScript (ES6), 51 bytes

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

Toma de entrada en la sintaxis currificación: f([1,2])(3).

Casos de prueba

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}

Mathematica, 27 bytes

^{Mathematica casi tiene un generador para esto}

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

Pruébalo en Wolfram Sandbox

Uso

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

{12, -1, 0, 1}

Explicación

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 *)

Mathematica, 58 bytes

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

Entrada

[{1}, 3]

Salida

{1,0,0}

Perl 6 , 36 bytes

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

Pruébalo

Expandido:

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

APL (Dyalog) , 22 bytes

Toma lcomo argumento izquierdo y aun argumento derecho.

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

Pruébalo en línea!

{...}  función anónima, donde ⍺es el argumento de la izquierda ( l) y ⍵el argumento de la derecha ( a).

 ≢⍵ cuenta (longitud) de a

 ⍺÷⍨ dividido por l

 ⌈ techo (redondeado)

 ⍺,⍨ adjuntar l

 s← almacenar en s(para s hape)

 ×/ producto de eso (es decir, cuántos enteros se necesitan)

 ⍵↑⍨ tomar tantos enteros de a(relleno con ceros)

 s⍴ r forma para dar formas (filas, columnas)

 +⌿ sumas en columnas

Haskell , 59 49 bytes

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

Pruébalo en línea!

Perl 6 , 40 bytes

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

Pruébalo en línea!

Si te gusta el número 42, se puede intercambiar la *de una∞ . Eso lo hará 42 bytes :—).

Explicacion :

{[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.

La magia detrás de la última "suma" es que el operador es un "reducir con zip con +". Por cierto, esto se rompería si lo usáramos solo en una lista con 1 lista dentro, pero eso nunca sucede si la lista original no está vacía (debido a la penúltima fila). También tenga en cuenta que terminamos tomando no solo @a, sino también @a * $lartículos. Afortunadamente, agregamos solo ceros que no afectarán el resultado final.

Casco , 9 bytes

S↑ȯ¡¬Fż+C

Pruébalo en línea!

Explicación

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

Pyth , 8 bytes

m+F%Q>vz

Pruébalo aquí!

Pyth , 10 bytes

sMCc.[EZQQ

Pruébalo aquí!

Explicación

Explicación # 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.

Explicación # 2

sMCc. [EZQQ Programa completo.

    . [E Rellene la segunda entrada a la derecha, con copias repetidas de ...
       Z ... Cero (0), hasta el múltiplo más cercano de ...
        Q ... La primera entrada.
   c Q Cortar en trozos de longitud igual a la primera entrada.
  C Matriz de transposición. Obtenga todas las columnas de la lista anidada.
sM Suma cada uno.
             Salida (implícitamente). 

J , 15 12 bytes

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

Pruébalo en línea!

Explicación

]{.+/@(]\~-)  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

05AB1E , 8 bytes

ô0ζO²Å0+

Pruébalo en línea!

ô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

05AB1E , 8 bytes

Å0+¹ô0ζO

Pruébalo en línea!

Å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

SOGL V0.12 , 14 bytes

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

Pruébalo aquí! o Pruebe todos los casos de prueba. esto se escribe como una función sin nombre y se espera chunk length; arrayen la pila.

Explicación:

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

05AB1E , 12 bytes

gs÷*+Å0¹+ôøO

Pruébalo en línea!

Explicación

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

Mathematica, 43 bytes

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

Clojure , 42 bytes

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

Pruébalo en línea!

R , 62 57 bytes

-5 bytes gracias al usuario2390246

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

Pruébalo en línea!

Actualizado ya que ya no tiene que manejar el caso vacío

rellena acon ceros, construye una matriz de lfilas y calcula y devuelve las sumas de filas.

Apilado , 24 bytes

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

Pruébalo en línea!

Explicación

[:@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

Java (OpenJDK 8) , 64 bytes

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

Pruébalo en línea!

Japt , 7 bytes

¡Hombre, luché con el método Japt incorrecto durante demasiado tiempo tratando de que funcione para el [1], 3caso de prueba en una cantidad razonable de bytes!

VÆëVX x

Intentalo

Explicación

Entrada implícita de matriz Uy entero V.

VÆ

Generar una matriz de enteros de 0a V-1y pasar cada uno a través de una función con Xser el elemento actual.

ëVX

Agarra cada Velemento de U, comenzando en el índice X.

x

Reduzca esa matriz por adición.

C, (GCC) 101 86 Bytes

Pruébalo en línea!

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);}}

Uso

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]);
   }
}

Tenga en cuenta que debe pasar la longitud de la (s) matriz (s) y una nueva matriz dinámica en el montón (m).

PowerShell , 62 bytes

param($a,$l)1..$l|%{$y=--$_;($o=0)..$l|%{$o+=$a[$y+$_*$l]};$o}

Pruébalo en línea!

Tomamos input $array y $length. Luego pase de 1a $l. Cada iteración establecemos que helper $ysea ​​uno menos que el número actual (esto se debe a que PowerShell 0-indexa pero la $lprofundidad está en 1-indexing). Luego establecemos nuestro $orendimiento 0y hacemos un bucle nuevamente $l. Cada iteración interna simplemente la estamos acumulando en $oel $aelemento de matriz adecuadamente indexado . Esto aprovecha el hecho de que la indexación más allá del final de la matriz devuelve $nully 0 + $null = 0.

Una vez que se realiza el bucle interno, salimos $oy pasamos al siguiente fragmento. Las diversas salidas se dejan en la tubería y la salida a través implícito Write-Outputocurre al finalizar el programa.

Perl 5 , 44 + 1 (-a) = 45 bytes

@r=(0)x($l=<>);map$r[$i++%$l]+=$_,@F;say"@r"

Pruébalo en línea!

Editar: se corrigió el caso donde la longitud solicitada era menor que la matriz de entrada

Casco , 10 bytes

Fż+So:`R0C

Pruébalo en línea!

Ungolfed / Explicación

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

Scala 2.12.2 , 80 bytes

(a:Array[Int],b:Int)=>(0 to b-1).map(i=>a.indices.filter(_%b==i).collect(a).sum)

Es un poco más corto que la solución Java.