오늘날의 과제는 배열을 가져 와서 청크로 나눈 다음 해당 청크를 추가하는 것입니다.

작동 방식은 다음과 같습니다. 프로그램이나 함수에는 정수 배열 a과 청크 크기가 부여 L됩니다. L배열의 길이를 나눌 수없는 경우 배열을 size의 배열로 분할해야합니다 L. 배열이 청크되면 모든 청크가 요소별로 함께 추가됩니다. 결과 배열이 출력됩니다.

L0보다 크다고 가정 할 수 있습니다 a. a의 내용이 긍정적 이라고 가정 할 수 없습니다 .

예를 들면 다음과 같습니다.

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

테스트 사례 :

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]

이것은 code-golf 이며 가장 적은 바이트 수입니다!

MATL , 4 바이트

e!Xs

온라인으로 사용해보십시오!

내가 쓴 MATL 코드의 첫 비트! a행 벡터 (쉼표로 구분)와 l숫자 로 두 개의 입력을 받습니다. 작동합니다

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

파이썬 3 , 67 65 42 바이트

빈 배열의 합이 0이라는 사실을 사용합니다.

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

온라인으로 사용해보십시오!

젤리 , 7 6 바이트

Dennis 덕분에 1 바이트.

;0$¡sS

온라인으로 사용해보십시오!

자바 7, 86 바이트

멋진 폴드 또는 매트릭스가 없으며 좋은 for루프 형식의 루프 :)

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

Ideone에서 사용해보십시오

안을 댄:

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

파이썬 2 , 49 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 51 바이트

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

카레 구문으로 입력을 f([1,2])(3)받습니다 : .

테스트 사례

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}

수학, 27 바이트

^{Mathematica는이를 위해 거의 내장되어있었습니다}

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

Wolfram Sandbox에서 사용해보십시오

용법

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

{12, -1, 0, 1}

설명

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

수학, 58 바이트

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

입력

[{1}, 3]

산출

{1,0,0}

펄 6 , 36 바이트

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

그것을 테스트

넓히는:

{  # 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 바이트

소요 l왼쪽 인자와 같은 a권리 인수입니다.

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

온라인으로 사용해보십시오!

{… 왼쪽 인수 ( )와 오른쪽 인수 ( ) 는 } 익명 함수 입니다.⍺l⍵a

 ≢⍵ 탈리 (길이) a

 ⍺÷⍨ 으로 나누기 l

 ⌈ 천장 (반올림)

 ⍺,⍨ 덧붙이다 l

 s← 저장하다 s( s hape)

 ×/ 그것의 곱 (즉, 필요한 정수의 수)

 ⍵↑⍨ 많은 정수를 가져옵니다 a(0으로 채 웁니다)

 s⍴ R의 형상 eshape s(행, 열)

 +⌿ 원주 합계

하스켈 , 59 49 바이트

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

온라인으로 사용해보십시오!

펄 6 , 40 바이트

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

온라인으로 사용해보십시오!

당신이 수 (42)를 좋아하는 경우에, 당신은을 교체 할 수 있습니다 *을 위해 ∞. 그러면 42 바이트가됩니다 :—).

설명 :

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

마지막 "add up"의 마술은 연산자가 "zip으로 삭감 +"입니다. 그건 그렇고, 목록이 1 인 목록에서만 사용하면 고장 나지만 원래 목록이 비어 있지 않은 경우 (두 번째에서 마지막 행으로 인해) 발생하지 않습니다. 또한 우리는 아이템 @a뿐만 아니라 @a * $l아이템도 가져옵니다 . 다행히도 최종 결과에 영향을 미치지 않는 0 만 추가했습니다.

껍질 , 9 바이트

S↑ȯ¡¬Fż+C

온라인으로 사용해보십시오!

설명

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

Pyth , 8 바이트

m+F%Q>vz

여기 사용해보십시오!

Pyth , 10 바이트

sMCc.[EZQQ

여기 사용해보십시오!

설명

설명 # 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.

설명 # 2

sMCc. [EZQQ 전체 프로그램.

    . [E 두 번째 입력을 오른쪽으로 반복해서 복사합니다.
       Z ... 0의 가장 가까운 배수까지
        Q ... 첫 번째 입력.
   c Q 첫 번째 입력과 같은 길이의 청크로 잘라냅니다.
  C 매트릭스 전치. 중첩 목록의 모든 열을 가져옵니다.
sM 합계.
             출력 (암시 적으로). 

J , 15 12 바이트

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

온라인으로 사용해보십시오!

설명

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

ô0ζO²Å0+

온라인으로 사용해보십시오!

ô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 바이트

Å0+¹ô0ζO

온라인으로 사용해보십시오!

Å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 바이트

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

여기 사용해보십시오! 또는 모든 테스트 사례를 시도하십시오. 이것은 명명되지 않은 함수로 작성되며 chunk length; array스택에서 예상 됩니다.

설명:

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 바이트

gs÷*+Å0¹+ôøO

온라인으로 사용해보십시오!

설명

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

수학, 43 바이트

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

클로저 , 42 바이트

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

온라인으로 사용해보십시오!

R , 62 57 바이트

user2390246 덕분에 -5 바이트

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

온라인으로 사용해보십시오!

더 이상 빈 케이스를 처리 할 필요가 없으므로 업데이트되었습니다.

패드 a제로와는 매트릭스 구축 l행 및 계산하여 반환 로우 합들을.

스택 형 , 24 바이트

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

온라인으로 사용해보십시오!

설명

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

자바 (OpenJDK 8) , 64 바이트

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

온라인으로 사용해보십시오!

Japt , 7 바이트

남자, 나는 잘못된 Japt 방법으로 너무 오랫동안 싸웠다 [1], 3.

VÆëVX x

시도 해봐

설명

어레이의 묵시적 입력 U정수 V.

VÆ

에서 정수 배열을 생성 0하는 V-1과 함께 기능을 각각 통과 X전류 소자 인.

ëVX

index에서 시작하여 V의 모든 요소를 가져 옵니다 .UX

x

추가하여 해당 배열을 줄입니다.

C, (GCC) 101 86 바이트

온라인으로 사용해보십시오!

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

용법

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

배열의 길이와 힙의 새 동적 배열 (m)을 전달해야합니다.

PowerShell , 62 바이트

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

온라인으로 사용해보십시오!

우리는 입력 $a레이와 $length를 취합니다 . 그런 다음에서 1로 반복하십시오 $l. 우리가 헬퍼 $y를 설정 한 각 반복 은 현재 수보다 1이 작습니다 (이것은 PowerShell 0 인덱스이지만 $length는 1 인덱싱에 있기 때문입니다 ). 그런 다음 $output을 설정하고 0다시 반복합니다 $l. 각각의 내부 반복은 단순히 $o적절하게 색인 된 $array 요소에 누적됩니다 . 이 배열 반환의 끝을지나 색인 사실 활용 $null과 0 + $null = 0.

내부 루프가 완료되면 출력 $o하고 다음 청크로 넘어갑니다. 다양한 출력이 파이프 라인에 남아 Write-Output있고 프로그램 완료시 암시 적을 통한 출력이 발생합니다.

펄 5 , 44 + 1 (-a) = 45 바이트

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

온라인으로 사용해보십시오!

편집 : 요청 된 길이가 입력 배열보다 작은 경우 고정

껍질 , 10 바이트

Fż+So:`R0C

온라인으로 사용해보십시오!

언 골프 / 설명

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

스칼라 2.12.2 , 80 바이트

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

Java 솔루션보다 약간 짧습니다.