Ваша задача сегодня состоит в том, чтобы взять массив, разбить его на куски и добавить эти куски.

Вот как это работает: вашей программе или функции будет задан массив целых чисел aи размер фрагмента L. Массив должен быть разбит на массивы по размеру L, если длина массива не делится, Lтогда к массиву должны быть добавлены 0, чтобы он был равномерно делим. Как только массив будет разбит на части, все порции должны быть добавлены вместе поэлементно. Полученный массив затем выводится.

Вы можете предположить, Lчто больше 0, и это 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]

Это код-гольф , побеждает меньше байтов!

MATL , 4 байта

e!Xs

Попробуйте онлайн!

Первый фрагмент кода MATL, который я написал! Принимает два ввода, aкак вектор строки (через запятую) и lкак число. Работает быть

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

Python 3 , 67 65 42 байта

Использует тот факт, что сумма пустого массива равна 0

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

Попробуйте онлайн!

Желе , 7 6 байт

1 байт благодаря Денису.

;0$¡sS

Попробуйте онлайн!

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

Python 2 , 49 байт

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

Попробуйте онлайн!

JavaScript (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}

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

Mathematica, 58 байт

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

вход

[{1}, 3]

Выход

{1,0,0}

Perl 6 , 36 байт

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

Попробуй это

Expanded:

{  # 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 (Дьялог) , 22 байта

Принимает в lкачестве левого аргумента и aправого аргумента.

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

Попробуйте онлайн!

{… } Анонимная функция где ⍺левый аргумент ( l) и ⍵правый аргумент ( a).

 ≢⍵ счет (длина) a

 ⍺÷⍨ разделить на l

 ⌈ потолок (вверх)

 ⍺,⍨ Append l

 s← хранить в s(для с HAPE)

 ×/ продукт этого (то есть, сколько нужно целых чисел)

 ⍵↑⍨ взять столько целых чисел a(заполнение нулями)

 s⍴ г eshape к формеs (строки, столбцы)

 +⌿ столбчатые суммы

Haskell , 59 49 байтов

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

Попробуйте онлайн!

Perl 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.

Волшебство, стоящее за последним «сложением», заключается в том, что оператор является «уменьшить с помощью z +». Между прочим, это сломалось бы, если бы мы использовали его только в списке с 1 списком внутри, но этого никогда не произойдет, если исходный список будет непустым (из-за строки, идущей от второй к последней). Также обратите внимание, что в итоге мы берем не только вещи @a, но и @a * $lпредметы. К счастью, мы добавили только нули, которые не повлияют на конечный результат.

Шелуха , 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 Pad второй вход справа, с повторными копиями ...
       Z ... Ноль (0), до ближайшего кратного ...
        Q ... Первый вход.
   c Q Нарезать куски длиной, равной первому входу.
  С Матрица транспонировать. Получить все столбцы вложенного списка.
см сумма каждого.
             Вывод (неявно). 

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

Mathematica, 43 байта

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

Clojure , 42 байта

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

Попробуйте онлайн!

R , 62 57 байт

-5 байт благодаря пользователю 2390246

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

Java (OpenJDK 8) , 64 байта

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

Попробуйте онлайн!

Japt , 7 байт

Чувак, я слишком долго боролся с неправильным методом Джапта, пытаясь заставить его работать на [1], 3 тестового примера в разумном количестве байтов!

VÆëVX x

Попытайся

объяснение

Неявный ввод массива Uи целого числа V.

VÆ

Создайте массив целых чисел от и 0до V-1каждого из них через функцию с Xтекущим элементом.

ëVX

Возьмите каждый Vэлемент U, начиная с индекса X.

x

Уменьшите этот массив путем сложения.

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

Обратите внимание, что вы должны передать длину массива (ов) и новый динамический массив в куче (м).

PowerShell , 62 байта

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

Попробуйте онлайн!

Мы берем входные данные $aRray и $lEngth. Затем цикл от 1до $l. На каждой итерации мы устанавливаем значение помощника $yна единицу меньше текущего числа (это потому, что PowerShell 0-indexes, а $length находится в 1-indexing). Затем мы устанавливаем нашу производительность $oв 0и повторяем цикл до $l. Каждую внутреннюю итерацию мы просто накапливаем в $oсоответствующем проиндексированном $aэлементе Rray. Это использует тот факт, что индексирование после конца массива возвращает $nullи 0 + $null = 0.

Как только внутренний цикл завершен, мы выводим $oи переходим к следующему фрагменту. Различные выходы остаются в конвейере, а вывод через неявное Write-Outputпроисходит после завершения программы.

Perl 5 , 44 + 1 (-a) = 45 байт

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

Попробуйте онлайн!

Редактировать: исправил случай, когда запрашиваемая длина была меньше, чем входной массив

Шелуха , 10 байт

Fż+So:`R0C

Попробуйте онлайн!

Ungolfed / Пояснение

             -- 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 байт

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

Это немного короче, чем решение Java.