Thử thách của bạn hôm nay là lấy một mảng, chia nó thành các khối và thêm các khối đó.

Đây là cách thức hoạt động: Chương trình hoặc chức năng của bạn sẽ được cung cấp một mảng các số nguyên avà kích thước khối L. Mảng nên được chia thành các mảng có kích thước L, nếu chiều dài của mảng không chia hết cho Lthì mảng phải có 0 được nối với nó để nó chia đều. Khi mảng được phân đoạn, tất cả các khối sẽ được thêm vào cùng với phần tử. Mảng kết quả là đầu ra.

Bạn có thể giả sử Llà lớn hơn 0 và đó alà không trống. Bạn không thể đưa ra giả định rằng anội dung của nó là tích cực.

Đây là một ví dụ:

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

Các trường hợp thử nghiệm:

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]

Đây là mã golf , ít byte thắng nhất!

MATL , 4 byte

e!Xs

Hãy thử trực tuyến!

Bit đầu tiên của mã MATL tôi đã viết! Có hai đầu vào, adưới dạng một vectơ hàng (được phân tách bằng dấu phẩy) và ldưới dạng số. Làm việc để được

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

Python 3 , 67 65 42 byte

Sử dụng thực tế là tổng của một mảng trống là 0

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

Hãy thử trực tuyến!

Thạch , 7 6 byte

1 byte nhờ Dennis.

;0$¡sS

Hãy thử trực tuyến!

Java 7, 86 byte

Không có nếp gấp hoặc ma trận ưa thích, chỉ là một forvòng lặp thời trang ol tốt :)

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

Hãy thử nó trên Ideone

Xếp hàng:

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 byte

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

Hãy thử trực tuyến!

JavaScript (ES6), 51 byte

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

Đưa đầu vào theo cú pháp currying : f([1,2])(3).

Các trường hợp thử nghiệm

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}

Toán học, 27 byte

^{Mathematica gần như đã có một nội dung cho việc này}

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

Dùng thử trên Wolfram Sandbox

Sử dụng

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

{12, -1, 0, 1}

Giải trình

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

Toán học, 58 byte

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

Đầu vào

[{1}, 3]

Đầu ra

{1,0,0}

Perl 6 , 36 byte

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

Kiểm tra nó

Mở rộng:

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

Đưa ra lnhư là đối số bên trái và amột đối số bên phải.

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

Hãy thử trực tuyến!

{... } chức năng ẩn danh nơi ⍺là lập luận trái ( l) và ⍵lập luận đúng ( a).

 ≢⍵ kiểm đếm (chiều dài) của a

 ⍺÷⍨ chia cho l

 ⌈ trần nhà (làm tròn lên)

 ⍺,⍨ chắp thêm l

 s← cửa hàng ở s(đối với s Hape)

 ×/ sản phẩm đó (nghĩa là cần bao nhiêu số nguyên)

 ⍵↑⍨ lấy nhiều số nguyên từ a(đệm với số không)

 s⍴ r eshape để định hình s(hàng, cột)

 +⌿ tổng cột

Haskell , 59 49 byte

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

Hãy thử trực tuyến!

Perl 6 , 40 byte

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

Hãy thử trực tuyến!

Nếu bạn thích số 42, bạn có thể đổi *lấy một ∞. Điều đó sẽ làm cho nó 42 byte:.

Giải thích :

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

Điều kỳ diệu đằng sau lần "cộng dồn" cuối cùng là toán tử là "giảm bằng zip với +". Nhân tiện, điều này sẽ bị hỏng nếu chúng ta chỉ sử dụng nó trong danh sách có 1 danh sách bên trong, nhưng điều đó không bao giờ xảy ra nếu danh sách ban đầu không trống (do hàng thứ hai đến cuối cùng). Cũng lưu ý rằng chúng tôi cuối cùng không chỉ lấy @a, mà còn @a * $lcác mặt hàng. May mắn thay, chúng tôi chỉ thêm các số 0 sẽ không ảnh hưởng đến kết quả cuối cùng.

Husk , 9 byte

S↑ȯ¡¬Fż+C

Hãy thử trực tuyến!

Giải trình

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

Bình thường , 8 byte

m+F%Q>vz

Hãy thử nó ở đây!

Bình thường , 10 byte

sMCc.[EZQQ

Hãy thử nó ở đây!

Giải trình

Giải thích số 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.

Giải thích số 2

sMCc. [EZQQ Chương trình đầy đủ.

    . [E Pad đầu vào thứ hai ở bên phải, với các bản sao lặp lại của ...
       Z ... Không (0), lên tới bội số gần nhất của ...
        Q ... Đầu vào đầu tiên.
   c Q Cắt thành các đoạn có độ dài bằng với đầu vào đầu tiên.
  C Ma trận chuyển vị. Lấy tất cả các cột của danh sách lồng nhau.
sM Tổng mỗi.
             Đầu ra (ngầm). 

J , 15 12 byte

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

Hãy thử trực tuyến!

Giải trình

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

ô0ζO²Å0+

Hãy thử trực tuyến!

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

Å0+¹ô0ζO

Hãy thử trực tuyến!

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

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

Hãy thử nó ở đây! hoặc Thử tất cả các trường hợp thử nghiệm. đây được viết như là một hàm không tên và mong đợi chunk length; arraytrên stack.

Giải trình:

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 byte

gs÷*+Å0¹+ôøO

Hãy thử trực tuyến!

Giải trình

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

Toán học, 43 byte

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

Clojure , 42 byte

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

Hãy thử trực tuyến!

R , 62 57 byte

-5 byte nhờ người dùng2390246

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

Hãy thử trực tuyến!

Cập nhật vì nó không còn phải xử lý các trường hợp trống.

các miếng đệm acó số không, xây dựng một ma trận các lhàng và tính toán và trả về các hàng tổng.

Xếp chồng , 24 byte

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

Hãy thử trực tuyến!

Giải trình

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

Hãy thử trực tuyến!

Japt , 7 byte

Man, tôi đã chiến đấu với phương pháp Japt sai quá lâu khi cố gắng làm cho nó hoạt động cho [1], 3trường hợp thử nghiệm với số lượng byte hợp lý!

VÆëVX x

Thử nó

Giải trình

Đầu vào ngầm định của mảng Uvà số nguyên V.

VÆ

Tạo một mảng các số nguyên từ 0đến V-1và chuyển từng thông qua một hàm với Xthành phần tử hiện tại.

ëVX

Lấy mọi Vyếu tố thứ U, bắt đầu từ chỉ số X.

x

Giảm mảng đó bằng cách thêm.

C, (GCC) 101 86 byte

Hãy thử trực tuyến!

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

Sử dụng

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

Lưu ý rằng bạn phải vượt qua độ dài của (các) mảng và một mảng động mới trên heap (m).

PowerShell , 62 byte

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

Hãy thử trực tuyến!

Chúng tôi có đầu vào $array và $length. Sau đó lặp từ 1đến $l. Mỗi lần lặp, chúng tôi đặt trình trợ giúp $ynhỏ hơn một số hiện tại (điều này là do PowerShell 0-index nhưng $length nằm trong 1-index). Sau đó, chúng tôi thiết lập thông tin của chúng tôi $ođể0 và lặp lại lên đến $l. Mỗi lần lặp bên trong, chúng ta chỉ cần tích lũy vào phần tử rray $ođược lập chỉ mục thích hợp $a. Điều này thúc đẩy thực tế là lập chỉ mục qua cuối mảng trả về $nullvà 0 + $null = 0.

Sau khi hoàn thành vòng lặp bên trong, chúng ta xuất ra $ovà chuyển sang đoạn tiếp theo. Các đầu ra khác nhau được để lại trên đường ống và đầu ra thông qua ngầm Write-Outputxảy ra khi hoàn thành chương trình.

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

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

Hãy thử trực tuyến!

Chỉnh sửa: đã sửa trường hợp độ dài yêu cầu nhỏ hơn mảng đầu vào

Husk , 10 byte

Fż+So:`R0C

Hãy thử trực tuyến!

Ungolfed / Giải thích

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

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

Nó ngắn hơn một chút so với giải pháp Java.