Ihre heutige Herausforderung besteht darin, ein Array zu nehmen, es in Blöcke aufzuteilen und diese Blöcke hinzuzufügen.

So funktioniert das: Ihr Programm oder Ihre Funktion erhält ein Array von Ganzzahlen aund eine Blockgröße L. Das Array sollte in Arrays der Größe aufgeteilt Lwerden. Wenn die Länge des Arrays durch nicht teilbar ist, sollten an Ldas Array Nullen angehängt werden, damit es gleichmäßig teilbar ist. Sobald das Array aufgeteilt ist, müssen alle Blöcke elementweise addiert werden. Das resultierende Array wird dann ausgegeben.

Sie können davon ausgehen, dass Les größer als 0 ist, und das aist nicht leer. Sie können nicht davon ausgehen, dass ader Inhalt positiv ist.

Hier ist ein Beispiel:

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

Testfälle:

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]

Das ist Code-Golf , die wenigsten Bytes gewinnen!

MATL , 4 Bytes

e!Xs

Probieren Sie es online!

Das erste bisschen MATL-Code, das ich geschrieben habe! Nimmt zwei Eingaben aals Zeilenvektor (durch Kommas getrennt) und lals Zahl entgegen. Funktioniert zu sein

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

Python 3 , 67 65 42 Bytes

Verwendet die Tatsache, dass die Summe eines leeren Arrays 0 ist

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

Probieren Sie es online!

Gelee , 7 6 Bytes

1 Byte danke an Dennis.

;0$¡sS

Probieren Sie es online!

Java 7, 86 Bytes

Keine ausgefallenen Falten oder Matrizen, nur eine gute altmodische forSchleife :)

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

Probieren Sie es auf Ideone

Gefüttert:

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

Probieren Sie es online!

JavaScript (ES6), 51 Byte

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

Nimmt die Eingabe in currying Syntax: f([1,2])(3).

Testfälle

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 hatte dafür fast eine eingebaute}

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

Probieren Sie es auf Wolfram Sandbox

Verwendung

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

{12, -1, 0, 1}

Erläuterung

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

Eingang

[{1}, 3]

Ausgabe

{1,0,0}

Perl 6 , 36 Bytes

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

Probier es aus

Erweitert:

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

Nimmt lals linkes Argument und aals rechtes Argument.

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

Probieren Sie es online!

{… } Anonyme Funktion, bei der ⍺das linke Argument ( l) und ⍵das rechte Argument ( a) steht.

 ≢⍵ Tally (Länge) von a

 ⍺÷⍨ Teilen durch l

 ⌈ Decke (aufrunden)

 ⍺,⍨ anhängen l

 s← speichern in s(für s hape)

 ×/ Produkt davon (dh wie viele ganze Zahlen benötigt werden)

 ⍵↑⍨ nimm so viele ganze Zahlen von a(Auffüllen mit Nullen)

 s⍴ r eshape zu Form s(Zeilen, Spalten)

 +⌿ Spaltensummen

Haskell , 59 49 Bytes

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

Probieren Sie es online!

Perl 6 , 40 Bytes

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

Probieren Sie es online!

Wenn dir die Nummer 42 gefällt, kannst du die *gegen eine tauschen ∞. Das ergibt 42 Bytes: -).

Erklärung :

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

Die Magie hinter dem letzten "Add-Up" ist, dass der Operator ein "Reduzieren mit Reißverschluss mit +" ist. Übrigens würde dies zusammenbrechen, wenn wir es nur für eine Liste mit 1 Liste verwenden würden, aber das passiert nie, wenn die ursprüngliche Liste nicht leer war (aufgrund der vorletzten Zeile). Beachten Sie auch, dass wir am Ende nicht nur Artikel @a, sondern auch @a * $lGegenstände nehmen. Glücklicherweise haben wir nur Nullen hinzugefügt, die das Endergebnis nicht beeinflussen.

Schale , 9 Bytes

S↑ȯ¡¬Fż+C

Probieren Sie es online!

Erläuterung

        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

Probieren Sie es hier aus!

Pyth , 10 Bytes

sMCc.[EZQQ

Probieren Sie es hier aus!

Erläuterung

Erklärung # 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.

Erklärung # 2

sMCc. [EZQQ Vollständiges Programm.

    . [E Die zweite Eingabe rechts mit wiederholten Kopien von ... auffüllen.
       Z ... Null (0), bis zum nächsten Vielfachen von ...
        Q ... Die erste Eingabe.
   c Q In Stücke von gleicher Länge wie die erste Eingabe schneiden.
  C Matrix transponieren. Ruft alle Spalten der verschachtelten Liste ab.
sM Summe je.
             Ausgabe (implizit). 

J , 15 12 Bytes

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es 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

05AB1E , 8 Bytes

Å0+¹ô0ζO

Probieren Sie es 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

SOGL V0.12 , 14 Bytes

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

Probieren Sie es hier aus! oder Probieren Sie alle Testfälle aus. Dies wird als unbenannte Funktion geschrieben und erwartet chunk length; arrayauf dem Stapel.

Erläuterung:

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

R , 62 57 Bytes

-5 Bytes dank user2390246

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

Probieren Sie es online!

Aktualisiert, da der leere Fall nicht mehr verarbeitet werden muss.

Füllt amit Nullen auf, erstellt eine Matrix aus lZeilen und berechnet und gibt die Zeilensummen zurück.

Gestapelt , 24 Bytes

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

Probieren Sie es online!

Erläuterung

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

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

Probieren Sie es online!

Japt , 7 Bytes

Mann, ich habe viel zu lange mit der falschen Japt-Methode gekämpft und versucht, sie für den [1], 3Testfall in einer vernünftigen Menge von Bytes zum Laufen zu bringen !

VÆëVX x

Versuch es

Erläuterung

Implizite Eingabe von Array Uund Ganzzahl V.

VÆ

Generieren Sie ein Array von Ganzzahlen von 0bis V-1und durchlaufen Sie jeweils eine Funktion, wobei Xes sich um das aktuelle Element handelt.

ëVX

Ergreifen Sie jedes VElement von U, beginnend mit dem Index X.

x

Reduzieren Sie dieses Array durch Hinzufügen.

C, (GCC) 101 86 Bytes

Probieren Sie es 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);}}

Verwendung

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

Beachten Sie, dass Sie die Länge des Arrays (s) und ein neues dynamisches Array auf dem Heap (m) übergeben müssen.

PowerShell , 62 Byte

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

Probieren Sie es online!

Wir nehmen Input $aRay und $lEngth. Dann Schleife von 1bis $l. Bei jeder Iteration setzen wir helper $yauf eins weniger als die aktuelle Zahl (dies liegt daran, dass PowerShell 0-Indizes, die $lLänge jedoch 1-indiziert). Dann setzen wir unseren $output auf 0und wiederholen die Schleife auf $l. Jede innere Iteration wird einfach in $odem entsprechend indizierten $aStrahlenelement akkumuliert. Dies nutzt die Tatsache, dass die Indizierung nach dem Ende des Arrays $nullund zurückgibt 0 + $null = 0.

Sobald die innere Schleife fertig ist, geben wir aus $ound fahren mit dem nächsten Block fort. Die verschiedenen Ausgaben verbleiben in der Pipeline und werden implizit Write-Outputnach Abschluss des Programms ausgegeben .

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

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

Probieren Sie es online!

Bearbeiten: Der Fall, dass die angeforderte Länge kleiner als das Eingabearray war, wurde behoben

Schale , 10 Bytes

Fż+So:`R0C

Probieren Sie es online!

Ungolfed / Erklärung

             -- 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 ist etwas kürzer als die Java-Lösung.