Twoim wyzwaniem dzisiaj jest zabranie tablicy, podzielenie jej na części i dodanie tych części.

Oto jak to działa: Twój program lub funkcja otrzyma tablicę liczb całkowitych ai wielkość porcji L. Tablica powinna być podzielona na tablice o rozmiarze L, jeśli długość tablicy nie jest podzielna, Lwówczas tablica powinna mieć do niej dołączone zera, aby była równomiernie podzielna. Gdy tablica zostanie podzielona na fragmenty, wszystkie fragmenty należy dodać razem pod względem elementów. Powstała tablica jest następnie wyprowadzana.

Możesz założyć, że Ljest większa niż 0, a to nie ajest puste. Nie można założyć, że azawartość jest dodatnia.

Oto przykład:

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

Przypadki testowe:

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]

To jest golf golfowy , wygrywa najmniej bajtów!

MATL , 4 bajty

e!Xs

Wypróbuj online!

Pierwszy kawałek kodu MATL, który napisałem! Przyjmuje dwa dane wejściowe, ajako wektor wiersza (oddzielony przecinkami) i ljako liczba. Działa

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

Python 3 , 67 65 42 bajtów

Wykorzystuje fakt, że suma pustej tablicy wynosi 0

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

Wypróbuj online!

Galaretka , 7 6 bajtów

1 bajt dzięki Dennisowi.

;0$¡sS

Wypróbuj online!

Java 7, 86 bajtów

Żadnych fantazyjnych fałd ani matryc, po prostu dobra, staroświecka forpętla :)

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

Wypróbuj na Ideone

Prążkowany:

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 bajtów

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

Wypróbuj online!

JavaScript (ES6), 51 bajtów

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

Trwa wejście w składni currying: f([1,2])(3).

Przypadki testowe

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 bajtów

^{Mathematica prawie do tego ma wbudowaną funkcję}

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

Wypróbuj na Wolfram Sandbox

Stosowanie

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

{12, -1, 0, 1}

Wyjaśnienie

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 bajtów

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

Wkład

[{1}, 3]

Wydajność

{1,0,0}

Perl 6 , 36 bajtów

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

Sprawdź to

Rozszerzony:

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

Przyjmuje ljako lewy argument i aprawy argument.

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

Wypróbuj online!

{… } Anonimowa funkcja gdzie ⍺lewy argument ( l) i ⍵prawy argument ( a).

 ≢⍵ tally (długość) z a

 ⍺÷⍨ podzielić przez l

 ⌈ sufit (zaokrąglony w górę)

 ⍺,⍨ dodać l

 s← przechowywać w s(dla s hape)

 ×/ iloczyn tego (tj. ile liczb całkowitych jest potrzebnych)

 ⍵↑⍨ weź tyle liczb całkowitych a(wypełnienie zerami)

 s⍴ R eshape kształtu s(wiersze, kolumny)

 +⌿ sumy kolumnowe

Haskell , 59 49 bajtów

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

Wypróbuj online!

Perl 6 , 40 bajtów

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

Wypróbuj online!

Jeśli podoba Ci się liczba 42, możesz zamienić na *na ∞. To sprawi, że będzie to 42 bajty :—).

Objaśnienie :

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

Magia kryjąca się za ostatnim „dodaniem” polega na tym, że operator „redukuje za pomocą zip za pomocą +”. Nawiasem mówiąc, to by się zepsuło, gdybyśmy użyli go tylko na liście z 1 listą w środku, ale to się nigdy nie zdarzy, jeśli oryginalna lista nie będzie pusta (z powodu drugiego do ostatniego wiersza). Zauważ też, że ostatecznie zabieramy nie tylko przedmioty @a, ale także @a * $lprzedmioty. Na szczęście dodaliśmy tylko zera, które nie wpłyną na końcowy wynik.

Łuska , 9 bajtów

S↑ȯ¡¬Fż+C

Wypróbuj online!

Wyjaśnienie

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

Pyth , 8 bajtów

m+F%Q>vz

Wypróbuj tutaj!

Pyth , 10 bajtów

sMCc.[EZQQ

Wypróbuj tutaj!

Wyjaśnienie

Wyjaśnienie nr 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.

Wyjaśnienie nr 2

sMCc. [EZQQ Pełny program.

    . [E Pad drugie wejście z prawej strony, z powtarzanymi kopiami ...
       Z ... zero (0), do najbliższej wielokrotności ...
        Q ... Pierwsze wejście.
   c Q Posiekaj na kawałki o długości równej pierwszemu wejściowi.
  C Matryca transponowana. Pobierz wszystkie kolumny listy zagnieżdżonej.
sM Sumuj każdy.
             Dane wyjściowe (domyślnie). 

J , 15 12 bajtów

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

Wypróbuj online!

Wyjaśnienie

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

ô0ζO²Å0+

Wypróbuj 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 bajtów

Å0+¹ô0ζO

Wypróbuj 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 bajtów

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

Wypróbuj tutaj! lub Wypróbuj wszystkie przypadki testowe. jest to zapisane jako funkcja bez nazwy i oczekuje chunk length; arrayna stosie.

Wyjaśnienie:

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 bajtów

gs÷*+Å0¹+ôøO

Wypróbuj online!

Wyjaśnienie

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 bajty

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

Clojure , 42 bajty

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

Wypróbuj online!

R , 62 57 bajtów

-5 bajtów dzięki user2390246

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

Wypróbuj online!

Zaktualizowano, ponieważ nie musi już obsługiwać pustej skrzynki.

wstawia azera, konstruuje macierz lwierszy oraz oblicza i zwraca sumy wierszy.

Ułożone , 24 bajty

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

Wypróbuj online!

Wyjaśnienie

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

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

Wypróbuj online!

Japt , 7 bajtów

Człowieku, zbyt długo walczyłem z niewłaściwą metodą Japt, próbując zmusić ją do działania w [1], 3przypadku testowym w rozsądnej ilości bajtów!

VÆëVX x

Spróbuj

Wyjaśnienie

Domniemane wprowadzanie tablicy Ui liczby całkowitej V.

VÆ

Wygeneruj tablicę liczb całkowitych od 0do V-1i przepuść każdą przez funkcję Xbędącą bieżącym elementem.

ëVX

Chwyć każdy Velement U, zaczynając od indeksu X.

x

Zmniejsz tę tablicę poprzez dodanie.

C, (GCC) 101 86 bajtów

Wypróbuj 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);}}

Stosowanie

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

Pamiętaj, że musisz podać długość tablicy (-ów) i nową tablicę dynamiczną na stercie (m).

PowerShell , 62 bajty

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

Wypróbuj online!

Bierzemy $atablicę wejściową i ength $l. Następnie zapętlić od 1do $l. Każda iteracja ustawiamy helpera $yo jeden mniej niż bieżąca liczba (dzieje się tak, ponieważ PowerShell 0-indeksuje, ale $length ma 1-indeksowanie). Następnie ustawiamy nasz $output na 0i ponownie zapętlamy do $l. Każda wewnętrzna iteracja po prostu kumulujemy w $oodpowiednio indeksowanym $aelemencie tablicy. Wykorzystuje to fakt, że indeksowanie poza końcem tablicy zwraca $nulli 0 + $null = 0.

Po zakończeniu pętli wewnętrznej wysyłamy dane $oi przechodzimy do następnej porcji. Różne wyniki są pozostawione w potoku, a dane wyjściowe za pośrednictwem niejawnego mają Write-Outputmiejsce po zakończeniu programu.

Perl 5 , 44 + 1 (-a) = 45 bajtów

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

Wypróbuj online!

Edycja: naprawiono przypadek, w którym żądana długość była mniejsza niż tablica wejściowa

Łuska , 10 bajtów

Fż+So:`R0C

Wypróbuj online!

Niegolfowane / Wyjaśnienie

             -- 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 bajtów

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

Jest nieco krótszy niż rozwiązanie Java.