Votre défi aujourd'hui est de prendre un tableau, de le diviser en morceaux et d'ajouter ces morceaux.

Voici comment cela fonctionne: votre programme ou fonction recevra un tableau d'entiers aet une taille de bloc L. Le tableau doit être divisé en tableaux de taille L, si la longueur du tableau n'est pas divisible par, Lalors le tableau doit avoir des 0 ajoutés pour qu'il soit divisible de manière égale. Une fois que le tableau est fragmenté, tous les morceaux doivent être ajoutés ensemble par élément. Le tableau résultant est ensuite sorti.

Vous pouvez supposer qu'il Lest supérieur à 0, ce qui an'est pas vide. Vous ne pouvez pas faire l'hypothèse que son acontenu est positif.

Voici un exemple:

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

Cas de test:

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]

C'est le code-golf , le moins d'octets gagne!

MATL , 4 octets

e!Xs

Essayez-le en ligne!

Le premier morceau de code MATL que j'ai écrit! Prend deux entrées, acomme vecteur de ligne (séparé par des virgules) et lcomme nombre. Fonctionne pour être

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

Python 3 , 67 65 42 octets

Utilise le fait que la somme d'un tableau vide est 0

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

Essayez-le en ligne!

Gelée , 7 6 octets

1 octet merci à Dennis.

;0$¡sS

Essayez-le en ligne!

Java 7, 86 octets

Pas de plis ou matrices fantaisie, juste une bonne forboucle à l' ancienne :)

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

Essayez-le sur Ideone

Doublé:

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 octets

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

Essayez-le en ligne!

JavaScript (ES6), 51 octets

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

Prend entrée dans la syntaxe corroyage: f([1,2])(3).

Cas de test

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 octets

^{Mathematica avait presque une fonction intégrée pour cela}

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

Essayez-le sur Wolfram Sandbox

Usage

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

{12, -1, 0, 1}

Explication

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 octets

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

Contribution

[{1}, 3]

Sortie

{1,0,0}

Perl 6 , 36 octets

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

Essaye-le

Étendu:

{  # 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 octets

Prend lcomme argument gauche et aargument droit.

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

Essayez-le en ligne!

{… } Fonction anonyme où se ⍺trouve l'argument gauche ( l) et ⍵l'argument droit ( a).

 ≢⍵ décompte (longueur) de a

 ⍺÷⍨ diviser par l

 ⌈ plafond (arrondi)

 ⍺,⍨ ajouter l

 s← magasin s(pour s hape)

 ×/ produit de cela (c.-à-d. combien d'entiers sont nécessaires)

 ⍵↑⍨ prendre autant d'entiers a(remplissage avec des zéros)

 s⍴ r forme pour former s(lignes, colonnes)

 +⌿ sommes colonnaires

Haskell , 59 49 octets

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

Essayez-le en ligne!

Perl 6 , 40 octets

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

Essayez-le en ligne!

Si vous aimez le numéro 42, vous pouvez échanger le *pour un ∞. Cela fera 42 octets :—).

Explication :

{[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 magie derrière le dernier "add up" est que l'opérateur est un "réduire avec zip avec +". Au fait, cela tomberait en panne si nous ne l'utilisions que sur une liste avec 1 liste à l'intérieur, mais cela ne se produit jamais si la liste d'origine n'était pas vide (en raison de l'avant-dernière ligne). Notez également que nous finissons par prendre non seulement @a, mais des @a * $larticles. Heureusement, nous n'avons ajouté que des zéros qui n'affecteront pas le résultat final.

Coque , 9 octets

S↑ȯ¡¬Fż+C

Essayez-le en ligne!

Explication

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

Pyth , 8 octets

m+F%Q>vz

Essayez-le ici!

Pyth , 10 octets

sMCc.[EZQQ

Essayez-le ici!

Explication

Explication # 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.

Explication # 2

sMCc. [EZQQ Programme complet.

    . [E Tapez la deuxième entrée vers la droite, avec des copies répétées de ...
       Z ... Zéro (0), jusqu'au multiple de ...
        Q ... La première entrée.
   c Q Découpez en morceaux de longueur égale à la première entrée.
  C Transposition matricielle. Obtenez toutes les colonnes de la liste imbriquée.
sM somme chacun.
             Sortie (implicitement). 

J , 15 12 octets

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

Essayez-le en ligne!

Explication

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

ô0ζO²Å0+

Essayez-le en ligne!

ô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 octets

Å0+¹ô0ζO

Essayez-le en ligne!

Å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 octets

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

Essayez-le ici! ou Essayez tous les cas de test. ceci est écrit comme une fonction sans nom et attend chunk length; arraysur la pile.

Explication:

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 octets

gs÷*+Å0¹+ôøO

Essayez-le en ligne!

Explication

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 octets

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

Clojure , 42 octets

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

Essayez-le en ligne!

R , 62 57 octets

-5 octets grâce à user2390246

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

Essayez-le en ligne!

Mis à jour car il n'a plus à gérer le cas vide.

remplit ade zéros, construit une matrice de llignes, calcule et renvoie les sommes des lignes.

Empilé , 24 octets

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

Essayez-le en ligne!

Explication

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

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

Essayez-le en ligne!

Japt , 7 octets

Man, je me suis battu avec la mauvaise méthode Japt pendant trop longtemps en essayant de la faire fonctionner pour le [1], 3cas de test dans une quantité raisonnable d'octets!

VÆëVX x

Essayez-le

Explication

Entrée implicite de tableau Uet d'entier V.

VÆ

Générez un tableau d'entiers de 0à V-1et passez chacun par une fonction en Xétant l'élément courant.

ëVX

Saisissez chaque Vélément de U, en commençant à l'index X.

x

Réduisez ce tableau par addition.

C, (GCC) 101 86 octets

Essayez-le en ligne!

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

Notez que vous devez transmettre la longueur du ou des tableaux et un nouveau tableau dynamique sur le tas (m).

PowerShell , 62 octets

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

Essayez-le en ligne!

Nous prenons la $array d' entrée et $length. Bouclez ensuite de 1à $l. Chaque itération, nous définissons helper $yà un de moins que le nombre actuel (c'est parce que PowerShell 0-indexes mais le $length est en 1-indexation). Ensuite, nous définissons notre $osortie sur 0et bouclons à nouveau sur $l. Chaque itération interne que nous accumulons simplement dans $ol' $aélément rray correctement indexé . Cela exploite le fait que l'indexation après la fin du tableau renvoie $nullet 0 + $null = 0.

Une fois la boucle interne terminée, nous sortons $oet passons au morceau suivant. Les différentes sorties sont laissées sur le pipeline et la sortie via implicite Write-Outputse produit à la fin du programme.

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

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

Essayez-le en ligne!

Edit: correction du cas où la longueur demandée était plus petite que le tableau d'entrée

Décortiquer , 10 octets

Fż+So:`R0C

Essayez-le en ligne!

Non golfé / Explication

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

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

Elle est légèrement plus courte que la solution Java.