Trong thử thách đơn giản này, bạn được cung cấp một mảng đầu vào Lgồm các số nguyên không âm và số lượng thùng blớn hơn 0 nhưng không quá độ dài L. Mã của bạn phải trả về một mảng mới Mcó độ dài bvà đã làm hỏng mảng đó L. Điều này là dễ dàng nhất để giải thích với các ví dụ.

L = [1,0,5,1]và b = 2trả lại M = [1,6].

L = [0,3,7,2,5,1]và b = 3trả lạiM = [3,9,6].

Cho đến nay, rất đơn giản. Tuy nhiên trong câu hỏi bnày không nhất thiết phải chialen(L) . Trong trường hợp này, thùng cuối cùng sẽ chỉ có ít số hơn để tạo ra nó.

Mỗi thùng ngoại trừ có thể là thùng cuối cùng phải có cùng số lượng đóng góp vào tổng số của nó. Thùng cuối cùng phải không có nhiều số đóng góp cho nó hơn các thùng khác. Thùng cuối cùng phải có càng nhiều số đóng góp cho nó càng tốt theo các quy tắc khác.

L = [0,3,7,2,5,1]và b = 4trả lại M = [3,9,6,0]. M = [10,8,0,0]không phải là một đầu ra chấp nhận được vì thùng thứ ba không có số lượng tên đóng góp cho nó dưới dạng thùng 1và 2.

L = [0,3,7,2,5]và b = 2trả lại M = [10,7]. M = [3, 14]không phải là một đầu ra chấp nhận được vì thùng cuối cùng sẽ có 3các yếu tố đóng góp cho nó nhưng thùng đầu tiên chỉ có 2.

L = [1,1,1,1,1,1,1]và b = 3trả lạiM = [3,3,1].

Như một quy tắc cuối cùng, mã của bạn phải chạy trong thời gian tuyến tính.

Bạn có thể sử dụng bất kỳ ngôn ngữ hoặc thư viện nào bạn thích và có thể giả sử đầu vào được cung cấp theo bất kỳ cách nào bạn thấy thuận tiện.

Nó chỉ ra rằng có một số đầu vào không thể được giải quyết. Ví dụ [1,1,1,1,1]và b=4. Mã của bạn có thể xuất bất cứ thứ gì nó thích cho những đầu vào đó.

APL (Dyalog) , 19 byte

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

Hãy thử trực tuyến!

Chúng tôi gắn b zeros để mảng trước khi định hình lại nó thành nhiều phần bằng nhau ⌈⍺÷⍨≢⍵( ⌈ chiều dài L ÷ b ⌉ ) và tổng hợp chúng, như mô tả trong ,⍺⍴0, vì bất kỳ số lượng các điểm trống (mà không phải là một phần của mảng ban đầu) lớn hơn b - 1 sẽ được lấp đầy với ít nhất b - 1 phần tử từ các phần khác, điều này làm cho điểm cân bằng của nhóm cuối cùng ở mức tối đa b - 1 so với phần còn lại. Chúng tôi sử dụng b> b - 1 vì đó là mã golf.

Ví dụ: L với 15 phần tử và b = 3 sẽ không được nhóm thành

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

nhưng đúng hơn là (lưu ý cách 2 xgiây ngoài cùng "điền vào" các số 0 ngoài cùng bên trái)

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

trong khi một mảng 16 phần tử sẽ được lấp đầy bằng 2 ( 3 - 1 ) điểm trống, như

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

Hãy thử trực tuyến!

R , 75 71 70 63 byte

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

Hãy thử trực tuyến!

Miếng đệm này Lvới NAcho đến khi chiều dài là bội số của b, sau đó phải mất số tiền cột Lnhư một ma trận vớib các cột, loại bỏNA các giá trị.

Giải thích như một ngôn ngữ dựa trên ngăn xếp:

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

Hãy thử trực tuyến! Hoặc là xác minh tất cả các trường hợp thử nghiệm .

Giải trình

Hãy xem xét đầu vào 4, [0,3,7,2,5,1]như một ví dụ.

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

Đã lưu một byte nhờ @Kirill L.

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Haskell , 61 byte

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

Hãy thử trực tuyến!

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

Dùng thử trực tuyến tại đây .

Tìm thấy một cách ngắn hơn để viết i/(n/b+(n%b==0?0:1) ở đây: i/((n+b-1)/b)

Cảm ơn Olivier Grégoire vì đã chơi golf 3 byte.

Phiên bản bị đánh cắp:

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

Thuốc tiên , 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

Hãy thử trực tuyến!

Elixir tốt nhất có được chia thành các phần có độ dài n . Và nó không thể phân chia trần như số nguyên rất tốt, vì vậy chúng tôi thực hiện phân chia float, làm tròn nó lên. Thật không may, cách duy nhất để làm điều này dẫn đến một số float, vì vậy chúng ta làm tròn nó một lần nữa thành một số nguyên.

Perl 6 ,  52 51  50 byte

52 byte: Kiểm tra nó

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

51 byte: Kiểm tra nó

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

50 byte: Hãy thử nó

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

47 byte không cạnh tranh Kiểm tra nó

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

Nó không cạnh tranh như ».sumđược phép thực hiện các phép tính song song. Vì vậy, nó có thể hoặc không thể trong thời gian tuyến tính.

Mở rộng:

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

}

Than , 22 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｎθ

Đầu vào b.

Ａη

Đầu vào L.

Ｗ﹪Ｌηθ⊞η⁰

Đẩy a 0đến Lcho đến khi Lchiều dài chia hết cho b.

Ｅ⪪η÷ＬηθＩΣι

Chia Lchiều dài cho bvà chia Lthành các phần có độ dài đó, sau đó tổng hợp từng phần và truyền thành chuỗi cho đầu ra ẩn trên các dòng riêng biệt.

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

Hãy thử trực tuyến!

C (tiếng kêu) , 58 byte

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

Hãy thử trực tuyến!

f()lấy tham số như sau ::
Lcon trỏ tới mảng đầu vào
l: chiều dài của mảng đầu vào
b: số thùng
m : con trỏ tới bộ đệm nhận mảng mới

Sau đây là phiên bản đăng ký lại @ 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];}

Hàm ẩn danh, lấy mảng và số nguyên, trả về mảng

Tiềm năng chơi gôn duy nhất này đã được thay thế ceil(count($a)/$b))bằng (count($a)-1)/$b+1và viết tắt (count($a)-1)bằng ~-count($a). Phao kết quả được ngầm định chuyển thành số nguyên trongarray_chunk cuộc gọi.

Hãy thử trực tuyến .