Bugünkü zorluğunuz bir dizi almak, parçalara bölmek ve bu parçaları eklemek.

İşte böyle çalışır: Programınıza veya işlevinize bir tamsayı dizisi ave bir yığın boyutu verilecektir L. Dizi büyüklüğü diziler bölünmüş olmalıdır Ldizi uzunluğu tarafından bölünebilir değilse, Lbu bölünebilir, böylece buna eklenir 0 olması gereken en sonra dizi. Dizi bir kez topaklandığında, tüm topaklar eleman şeklinde birlikte eklenmelidir. Sonuçta ortaya çıkan dizi daha sonra çıktı.

Diyelim Lki 0'dan büyük ve bu ada boş değil. aİçeriğinin olumlu olduğu varsayımında bulunamazsınız .

İşte bir örnek:

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

Test durumları:

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]

Bu kod golf , en az bayt kazanıyor!

MATL , 4 bayt

e!Xs

Çevrimiçi deneyin!

İlk MATL kodunu yazdım! aBir satır vektörü (virgülle ayrılmış) ve lsayı olarak iki girdi alır . Olmak için çalışıyor

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

Python 3 , 67 65 42 bayt

Boş bir dizinin toplamının 0 olduğu gerçeğini kullanır

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

Çevrimiçi deneyin!

Jöle , 7 6 bayt

Dennis'e 1 bayt teşekkürler.

;0$¡sS

Çevrimiçi deneyin!

Java 7, 86 bayt

Süslü kıvrımlar veya matrisler yok, sadece güzel bir moda fordö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;}

Ideone'da dene

çizgili:

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 bayt

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

Çevrimiçi deneyin!

JavaScript (ES6), 51 bayt

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

Tımar sözdiziminde girişi Alır: f([1,2])(3).

Test Kılıfları

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 bayt

^{Mathematica'da neredeyse bunun için bir yerleşik vardı}

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

Wolfram Sandbox'ta dene

kullanım

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

{12, -1, 0, 1}

açıklama

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 bayt

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

Giriş

[{1}, 3]

Çıktı

{1,0,0}

Perl 6 , 36 bayt

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

Dene

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 (Dyalog) , 22 bayt

Alır lsol argüman gibi abir sağ argüman.

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

Çevrimiçi deneyin!

{… } Anonim işlev ⍺, sol argüman ( l) ve ⍵sağ argüman ( a).

 ≢⍵ taksitli (uzunluk) a

 ⍺÷⍨ bölünür l

 ⌈ tavan (yuvarlak)

 ⍺,⍨ ekleme l

 s← depolamak s( s hape için)

 ×/ bunun ürünü (yani kaç tam sayı gerekli)

 ⍵↑⍨ bu kadar tam sayı al a(sıfırlarla doldurma)

 s⍴ r şekli biçimlendirir s(satırlar, sütunlar)

 +⌿ sütunlu toplamlar

Haskell , 59 49 bayt

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

Çevrimiçi deneyin!

Perl 6 , 40 bayt

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

Çevrimiçi deneyin!

42 sayısını seviyorsanız, *bir için bir ∞. Bu 42 bayt yapacak: --).

Açıklama :

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

Son "ekleme" nin ardındaki sihir, operatörün "fermuar ile + ile azaltma" olmasıdır. Bu arada, sadece içinde 1 liste olan bir listede kullanırsak, bu bozulma olur, ancak orijinal liste boş değilse (ikinci-son satırdan dolayı) bu asla olmaz. Ayrıca sadece sonuna kadar alarak unutmayın @a, ancak @a * $löğeleri. Neyse ki, son sonucu etkilemeyecek yalnızca sıfırları ekledik.

Kabuğu , 9 bayt

S↑ȯ¡¬Fż+C

Çevrimiçi deneyin!

açıklama

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

Pyth , 8 bayt

m+F%Q>vz

Burada dene!

Pyth , 10 bayt

sMCc.[EZQQ

Burada dene!

açıklama

Açıklama # 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.

Açıklama 2

sMCc. [EZQQ Tam program.

    [E İkinci girişi sağa kaydırın, tekrarlanan kopyaları ...
       Z ... Zero (0), en yakın katına kadar ...
        Q ... İlk giriş.
   c Q İlk girişe eşit uzunluktaki parçalar halinde kesin.
  C Matrix devrik. İç içe listenin tüm sütunlarını al.
mM Her birini topla.
             Çıktı (örtük olarak). 

J , 15 12 bayt

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

Çevrimiçi deneyin!

açıklama

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

ô0ζO²Å0+

Çevrimiçi deneyin!

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

Å0+¹ô0ζO

Çevrimiçi deneyin!

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

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

Burada dene! veya Tüm test durumlarını deneyin. bu adsız bir işlev olarak yazılmıştır chunk length; arrayve yığında bekler .

Açıklama:

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 bayt

gs÷*+Å0¹+ôøO

Çevrimiçi deneyin!

açıklama

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 bayt

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

Clojure , 42 bayt

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

Çevrimiçi deneyin!

R , 62 57 bayt

User2390246 sayesinde -5 bayt

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

Çevrimiçi deneyin!

Artık boş davayı kullanmak zorunda olmadığından güncellendi.

asıfır içeren pedler , bir lsatır matrisi oluşturur ve satır toplamlarını hesaplar ve döndürür.

Yığılmış , 24 bayt

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

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!

Japt , 7 bayt

Dostum, çok uzun süredir yanlış Japt yöntemiyle savaştım, [1], 3test davası için makul miktarda bayt ile çalışmasını sağladım !

VÆëVX x

Dene

açıklama

Dizi Uve tamsayının örtük girişi V.

VÆ

Arasındaki tam bir dizi oluşturmak 0için V-1ve bir fonksiyonu sayesinde her geçişte Xakım elemanı olan.

ëVX

İndeksinden başlayarak her Velementini al .UX

x

Ekleyerek bu diziyi azaltın.

C, (GCC) 101 86 Bayt

Çevrimiçi deneyin!

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

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

Dizilerin uzunluğunu ve öbek (m) üzerindeki yeni bir dinamik diziyi geçmeniz gerektiğini unutmayın.

PowerShell , 62 bayt

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

Çevrimiçi deneyin!

Giriş $arayını alıp giriyoruz $l. Dan Sonra döngü 1için $l. Yardımcı seçtiğimiz her yineleme $y, geçerli sayının birinden az olacak (bunun nedeni PowerShell 0-endeksleridir, ancak $length 1-indekslemededir). Daha sonra $output'umuzu ayarladık 0ve tekrar döngü oluşturduk $l. Her bir iç yineleme $o, uygun şekilde indekslenmiş bir $array elemanında toplanıyoruz. Bu, dizinin sonundan sonraki indekslemenin döndürdüğü gerçeğini kullanır $nullve 0 + $null = 0.

İç döngü bittikten sonra, $oçıkıp bir sonraki parçaya geçiyoruz. Çeşitli çıktılar boru hattında bırakılır ve örtülü olarak çıktı Write-Outputprogram tamamlanırken olur.

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

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

Çevrimiçi deneyin!

Düzenleme: istenen uzunluğun giriş dizisinden daha küçük olması durumunda düzeltildi

Kabuğu , 10 bayt

Fż+So:`R0C

Çevrimiçi deneyin!

Ungolfed / Açıklama

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

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

Java çözümünden biraz daha kısadır.