Bu basit zorlukta, Lnegatif olmayan tamsayılardan oluşan bir girdi dizisi ve b0'dan büyük ancak uzunluğundan fazla olmayan bir dizi bölme verilir L. Kodunuz M, uzunluğu olan bve diziyi bölen yeni bir dizi döndürmelidir L. Bu en kolay örneklerle açıklanmıştır.

L = [1,0,5,1]ve b = 2geri döner M = [1,6].

L = [0,3,7,2,5,1]ve b = 3geri döner M = [3,9,6].

Şimdiye kadar, çok basit. Ancak bu soruda bmutlaka bölünmek zorunda değildir len(L). Bu durumda son bölmede telafi etmek için daha az sayı bulunur.

Muhtemelen sonuncusu hariç her bölme, toplamına katkıda bulunan aynı sayıda sayıya sahip olmalıdır. Son bölmede, diğer bölmelerden daha fazla sayı bulunmamalıdır. Son bölmede, diğer kurallara bağlı olarak mümkün olduğunca çok sayıda sayı olmalıdır.

L = [0,3,7,2,5,1]ve b = 4geri döner M = [3,9,6,0]. M = [10,8,0,0]üncü kutuda kutulara katkıda bulunan adların sayısı olmadığından kabul edilebilir bir çıktı değildir 1ve 2.

L = [0,3,7,2,5]ve b = 2geri döner M = [10,7]. M = [3, 14]son bölmede buna 3katkıda bulunan öğeler olacağından kabul edilebilir bir çıktı değildir, ancak ilk bölmede yalnızca öğe bulunur 2.

L = [1,1,1,1,1,1,1]ve b = 3geri döner M = [3,3,1].

Son kural olarak, kodunuzun doğrusal zamanda çalışması gerekir.

İstediğiniz dil veya kitaplıkları kullanabilirsiniz ve girdinin uygun bulduğunuz şekilde sağlandığını varsayabilirsiniz.

Çözülemeyen bazı girdiler olduğu ortaya çıkıyor. Örneğin [1,1,1,1,1]ve b=4. Kodunuz bu girişler için istediği her şeyi verebilir.

APL (Dyalog) , 19 bayt

{+/⍺(⌈⍺÷⍨≢⍵)⍴⍵,⍺⍴0}

Çevrimiçi deneyin!

Bu ekleme b eşit parçaya yeniden şekillendirilmesi önce diziye sıfır ⌈⍺÷⍨≢⍵( ⌈ ⌉ b ÷ L uzunluğu de gösterildiği gibi), ve bunların toplanmasıyla ,⍺⍴0daha büyük (orijinal dizisinin bir parçası değildir) boş noktalar herhangi bir miktar için, b - 1 , diğer parçalardan en az b - 1 elemanlarla doldurulacaktır , bu da son grubun dengeleme noktasını diğerlerinden en fazla b - 1 farkla yapar. Biz kullanmak 1 - b> b öyle çünkü kod golf.

Örneğin, L ile 15 elemanları ve 3 = b olarak gruplandırılabilir olmaz

x x x x x x
x x x x x x
x x x 0 0 0

daha ziyade (en sağdaki 2 xs'nin en soldaki sıfırları nasıl doldurduğunu unutmayın )

x x x x x
x x x x x
x x x x x

Bir süre 16 elemanları dizisi ile dolu olacak 2 ( 3-1 ) boş noktalar gibi

x x x x x x
x x x x x x
x x x x 0 0

Python 2 , 65 bayt

f=lambda l,n:n and[sum(l[:len(l)/n+1])]+f(l[len(l)/n+1:],n-1)or[]

Çevrimiçi deneyin!

R , 75 71 70 63 bayt

function(L,b)colSums(matrix(L[1:(ceiling(sum(L|1)/b)*b)],,b),T)

Çevrimiçi deneyin!

Bu pedler Lile NAuzunlukta bir katı kadar bsonra, sütun miktarda alır Lolan bir matris olarak bçıkarılması bölümlerinden NAdeğerleri.

Yığın tabanlı bir dil olarak açıklama:

function(L,b){
      (ceiling(sum(L|1)/b*b)  # push the next multiple of b >= length(L), call it X
    1:..                      # push the range 1:X
  L[..]                       # use this as an index into L. This forces L
                              # to be padded to length X with NA for missing values
        matrix(..,,b)         # create a matrix with b columns, using L for values
                              # and proceeding down each column, so
                              # matrix(1:4,,2) would yield [[1,3],[2,4]]
colSums(.., na.rm = T)        # sum each column, removing NAs

MATL , 6 bayt

vi3$es

Çevrimiçi deneyin! Veya tüm test senaryolarını doğrulayın .

açıklama

Giriş göz önünde 4, [0,3,7,2,5,1]bir örnek olarak.

v       % Vertically concatenate stack contents. Gives the empty array, []
        % STACK: []
i       % Input b
        % STACK: [], 4
        % Implicitly input L at the bottom of the stack
        % STACK: [0,3,7,2,5,1], [], 4
3$e     % 3-input reshape. This reshapes L with [] rows and b columns, in
        % column-major order (down, then across). [] here means that the
        % number of rows is chosen as needed to give b columns. Padding
        % with trailing zeros is applied if needed
        % STACK: [0 7 5 0;
                  3 2 1 0]
s       % Sum of each column
        % STACK: [3 9 6 0]
        % Implicitly display

Yakut , 54 53 bayt

@Kirill L. sayesinde bir bayt kurtardı.

->l,b{s=1.0*l.size/b;(1..b).map{l.shift(s.ceil).sum}}

Çevrimiçi deneyin!

C (gcc) , 107 bayt

j,k,t,Q;f(A,l,b)int*A;{for(j=~0;b>++j;printf("%d,",t))for(t=k=0;(Q=!!(l%b)+l/b)>k;t+=Q<l?A[Q]:0)Q=k+++Q*j;}

Çevrimiçi deneyin!

Haskell , 61 bayt

l#0=[]
l#n|o<-length l`div`n+1=sum(take o l):(drop o l)#(n-1)

Çevrimiçi deneyin!

Java 10, 96 89 86 bayt

a->b->{int r[]=new int[b],i=0,n=a.length;for(;i<n;)r[i/((n+b-1)/b)]+=a[i++];return r;}

Burada çevrimiçi deneyin .

Buraya yazmak için daha kısa bir yol i/(n/b+(n%b==0?0:1) buldum: i/((n+b-1)/b)

3 bayt golf yaptığı için Olivier Grégoire'a teşekkürler.

Ungolfed sürümü:

input -> bins -> { // input is int[] (original array), bins is int (number of bins)
    int result[] = new int[bins], // resulting array, initialized with all 0
    i = 0, // for iterating over the original array
    n = a.length; // length of the original array
    for(; i < n ;) // iterate over the original array
        result[i / ((n + bins - 1) / bins)] += input[i++]; // add the element to the right bin; that's bin n/bins if bins divides n, floor(n/bins)+1 otherwise
    return result;
}

İksir , 98 bayt

fn l,b->Enum.map Enum.chunk(l++List.duplicate(0,b-1),round Float.ceil length(l)/b),&Enum.sum/1 end

Çevrimiçi deneyin!

En iyi İksir, n uzunluğuna sahip parçalara ayrılır . Ve bölme tamsayı olarak çok iyi olamaz, bu yüzden yüzer bölme yaparız, yuvarlarız. Ne yazık ki bunu yapmanın tek yolu bir float ile sonuçlanır, bu yüzden tekrar bir tam sayıya yuvarlıyoruz.

Perl 6 ,  52 51  50 bayt

52 bayt: Test edin

->\L,\b{L.rotor(:partial,ceiling L/b)[^b].map: &sum}

51 bayt: Test edin

{@^a.rotor(:partial,ceiling @a/$^b)[^$b].map: &sum}

50 bayt: Deneyin

{map &sum,@^a.rotor(:partial,ceiling @a/$^b)[^$b]}

47 bayt rakipsiz Test et

{@^a.rotor(:partial,ceiling @a/$^b)[^$b]».sum}

».sumHesaplamaları paralel olarak yapmasına izin verildiği için rekabet etmiyor. Dolayısıyla doğrusal zamanda olabilir de olmayabilir de.

Expanded:

{  # bare block with two placeholder parameters ｢@a｣ and ｢$b｣

  map                   # for each sublist

    &sum,               # find the sum


    @^a                 # declare and use first parameter

    .rotor(             # break it into chunks

      :partial,         # include trailing values that would be too few otherwise

      ceiling @a / $^b # the number of elements per chunk

    )[ ^$b ]           # get the correct number of chunks if it would be too few

}

Kömür , 22 bayt

ＮθＡηＷ﹪Ｌηθ⊞η⁰Ｅ⪪η÷ＬηθＩΣι

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

Ｎθ

Giriş b.

Ａη

Giriş L.

Ｗ﹪Ｌηθ⊞η⁰

Bir itme 0için Lkadar Lbireyin uzunluğu ile bölünebilen b.

Ｅ⪪η÷ＬηθＩΣι

LUzunluğunu bu uzunluktaki bölümlere ayırın bve ayırın L, sonra her bölümü toplayın ve ayrı satırlarda örtük çıktı için dizeye yayınlayın.

JavaScript (Node.js) , 71 bayt

L=>b=>Array(b).fill().map((v,i)=>L.slice(s=i*b,s+b).reduce((x,y)=>x+y))

Çevrimiçi deneyin!

C (clang) , 58 bayt

i;f(*L,l,b,*m){b=l/b+!!(l%b);for(i=0;i<l;m[i++/b]+=L[i]);}

Çevrimiçi deneyin!

f()parametreleri aşağıdaki gibi alır
L:: giriş dizisine işaretçi: giriş dizisinin
luzunluğu
b: kutu sayısı
m: yeni diziyi alan arabelleğe işaretçi

Aşağıda @ 60 baytlık yeniden giriş yapan bir sürüm yer almaktadır:

f(*L,l,b,*m){b=l/b+!!(l%b);for(int i=0;i<l;m[i++/b]+=L[i]);}

PHP, 88 bayt

function($a,$b){return array_map(array_sum,array_chunk($a,~-count($a)/$b+1))+[$b-1=>0];}

anonim işlev, dizi ve tamsayı alır, dizi döndürür

Bu vardı sadece golf potansiyeli yerine geçecekti ceil(count($a)/$b))ile (count($a)-1)/$b+1ve abbreviating (count($a)-1)ile ~-count($a). Ortaya çıkan kayan nokta, örtük olarak array_chunkçağrıda tamsayıya dökülür .

Çevrimiçi deneyin .