Dalam tantangan sederhana ini Anda akan diberikan array input Lbilangan bulat non-negatif dan sejumlah nampan blebih besar dari 0 tetapi tidak lebih dari panjangnya L. Kode Anda harus mengembalikan array baru Myang panjangnya bdan yang telah membuang array L. Ini paling mudah dijelaskan dengan contoh.

L = [1,0,5,1]dan b = 2kembali M = [1,6].

L = [0,3,7,2,5,1]dan b = 3kembali M = [3,9,6].

Sejauh ini, sangat sederhana. Namun dalam pertanyaan bini tidak harus membelah len(L). Dalam hal ini, nampan terakhir hanya memiliki jumlah yang lebih sedikit untuk menebusnya.

Setiap bin kecuali mungkin yang terakhir harus memiliki jumlah angka yang sama yang berkontribusi terhadap totalnya. Nampan terakhir tidak boleh memiliki lebih banyak angka yang berkontribusi daripada nampan lainnya. Tempat sampah terakhir harus memiliki jumlah yang berkontribusi sebanyak mungkin sesuai dengan aturan lainnya.

L = [0,3,7,2,5,1]dan b = 4kembali M = [3,9,6,0]. M = [10,8,0,0]bukan keluaran yang dapat diterima karena nampan ketiga tidak memiliki nomor nama yang berkontribusi sebagai nampan 1dan 2.

L = [0,3,7,2,5]dan b = 2kembali M = [10,7]. M = [3, 14]bukan keluaran yang dapat diterima karena nampan terakhir akan memiliki 3elemen yang berkontribusi padanya tetapi yang pertama hanya memiliki 2.

L = [1,1,1,1,1,1,1]dan b = 3kembali M = [3,3,1].

Sebagai aturan terakhir, kode Anda harus dijalankan dalam waktu linier.

Anda dapat menggunakan bahasa atau perpustakaan apa saja yang Anda suka dan dapat berasumsi bahwa input disediakan dengan cara apa pun yang Anda rasa nyaman.

Ternyata ada beberapa input yang tidak bisa diselesaikan. Sebagai contoh [1,1,1,1,1]dan b=4. Kode Anda dapat menampilkan apa pun yang diinginkan untuk input tersebut.

APL (Dyalog) , 19 byte

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

Cobalah online!

Kami menambahkan b nol ke array sebelum membentuknya kembali menjadi bagian yang sama ⌈⍺÷⍨≢⍵( of panjang L ÷ b ⌉ ) dan menjumlahkannya, seperti yang digambarkan ,⍺⍴0, karena jumlah tempat kosong (yang bukan bagian dari array asli) lebih besar dari b - 1 akan diisi dengan setidaknya b - 1 elemen dari bongkahan lain, yang membuat titik penyeimbang grup terakhir maksimum b - 1 berbeda dari yang lain. Kami menggunakan b> b - 1 karena ini adalah kode golf.

Misalnya, L dengan 15 elemen dan b = 3 tidak akan dikelompokkan sebagai

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

melainkan sebagai (perhatikan bagaimana 2 xs paling kanan "mengisi" nol paling kiri)

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

sedangkan array 16 elemen akan diisi dengan 2 ( 3 - 1 ) tempat kosong, seperti

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

Python 2 , 65 byte

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

Cobalah online!

R , 75 71 70 63 byte

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

Cobalah online!

Ini bantalan Ldengan NAsampai panjangnya adalah kelipatan b, kemudian mengambil jumlah kolom Lsebagai matriks dengan bkolom, menghapus NAnilai-nilai.

Menjelaskan sebagai bahasa berbasis tumpukan:

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 byte

vi3$es

Cobalah online! Atau verifikasi semua kasus uji .

Penjelasan

Pertimbangkan input 4, [0,3,7,2,5,1]sebagai contoh.

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

Ruby , 54 53 byte

Menyimpan satu byte berkat @Kirill L.

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

Cobalah online!

C (gcc) , 107 byte

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

Cobalah online!

Haskell , 61 byte

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

Cobalah online!

Java 10, 96 89 86 byte

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

Cobalah online di sini .

Temukan cara yang lebih singkat untuk menulis di i/(n/b+(n%b==0?0:1) sini: i/((n+b-1)/b)

Terima kasih kepada Olivier Grégoire karena bermain golf 3 byte.

Versi tidak disatukan:

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

Elixir , 98 byte

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

Cobalah online!

Elixir terbaik yang dimiliki adalah membelah menjadi beberapa bagian dengan panjang n . Dan itu tidak dapat menghentikan pembagian sebagai integer dengan sangat baik, jadi kami melakukan pembagian float, mengumpulkannya. Sayangnya satu-satunya cara untuk melakukan ini menghasilkan float, jadi kami membulatkannya lagi menjadi integer.

Perl 6 ,  52 51  50 byte

52 byte: Uji itu

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

51 byte: Uji itu

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

50 byte: Cobalah

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

47 byte non-bersaing Uji itu

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

Ini tidak bersaing karena ».sumdiperbolehkan melakukan perhitungan secara paralel. Jadi mungkin atau tidak dalam waktu linier.

Diperluas:

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

}

Arang , 22 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

Ｎθ

Masukan b.

Ａη

Masukan L.

Ｗ﹪Ｌηθ⊞η⁰

Mendorong 0untuk Lsampai L's panjang habis dibagi b.

Ｅ⪪η÷ＬηθＩΣι

Bagi Lpanjang dengan bmembagi Lmenjadi beberapa bagian dari panjang itu, kemudian jumlah masing-masing bagian dan dilemparkan ke string untuk output implisit pada baris yang terpisah.

JavaScript (Node.js) , 71 byte

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

Cobalah online!

C (dentang) , 58 byte

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

Cobalah online!

f()mengambil parameter sebagai berikut::
Lpointer ke array input
l: panjang array input
b: jumlah sampah
m: pointer ke buffer yang menerima array baru

Berikut ini adalah versi kembali-masuk @ 60 byte:

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

PHP, 88 byte

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

fungsi anonim, mengambil array dan integer, mengembalikan array

Satu-satunya golf potensi ini harus telah menggantikan ceil(count($a)/$b))dengan (count($a)-1)/$b+1dan menyingkat (count($a)-1)dengan ~-count($a). Float yang dihasilkan secara implisit dilemparkan ke integer dalam array_chunkpanggilan.

Cobalah online .