У цьому простому виклику вам надається вхідний масив Lневід'ємних цілих чисел та кількість бін bбільше 0, але не більше довжини L. Ваш код повинен повернути новий масив M, довжина якого bі який бінірував масив L. Це найлегше пояснити на прикладах.

L = [1,0,5,1]і b = 2повертається M = [1,6].

L = [0,3,7,2,5,1]і b = 3повертається M = [3,9,6].

Поки так просто. Однак у цьому питанні bне обов’язково ділитися len(L). У цьому випадку в останньому смітнику буде лише менше номерів для його складання.

Кожен контейнер, крім можливо останнього, повинен мати однакову кількість номерів, що сприяє його загальній кількості. Останній контейнер не повинен мати більше внесених до нього номерів, ніж інші контейнери. Останній контейнер повинен мати якомога більше номерів, що сприяють йому, відповідно до інших правил.

L = [0,3,7,2,5,1]і b = 4повертається M = [3,9,6,0]. M = [10,8,0,0]не є прийнятним висновком, оскільки третій бін не має іменного числа чисел, що сприяють йому як біни 1та 2.

L = [0,3,7,2,5]і b = 2повертається M = [10,7]. M = [3, 14]не є прийнятним виведенням, оскільки останній бін матиме 3внесені до нього елементи, але перший має лише такий 2.

L = [1,1,1,1,1,1,1]і b = 3повертається M = [3,3,1].

Як остаточне правило, ваш код повинен працювати в лінійний час.

Ви можете використовувати будь-яку мову чи бібліотеки, які вам подобаються, і можна вважати, що введення надається будь-яким зручним для вас способом.

Виявляється, є деякі входи, які неможливо вирішити. Наприклад [1,1,1,1,1]і b=4. Ваш код може виводити все, що заманеться для цих входів.

APL (Dyalog) , 19 байт

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

Спробуйте в Інтернеті!

Ми додаємо b нулі до масиву, перш ніж перерозподілити його на рівні частини ⌈⍺÷⍨≢⍵( ⌈ довжина L ÷ b ⌉ ) та підсумувати їх, як зображено на рисунку ,⍺⍴0, оскільки будь-яка кількість порожніх плям (які не є частиною вихідного масиву) більша ніж b - 1 буде заповнений щонайменше b - 1 елементами з інших фрагментів, що робить точку врівноваження останньої групи максимальною b - 1 різницею від решти. Ми використовуємо b> b - 1, оскільки це код гольфу.

Наприклад, L з 15 елементами і b = 3 не згрупуються як

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

а скоріше як (зверніть увагу, як найменша права частина 2 x"заповнює" ліві нулі)

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

тоді як масив 16 елементів буде заповнений 2 ( 3 - 1 ) порожніми плямами, як

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

Python 2 , 65 байт

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

Спробуйте в Інтернеті!

R , 75 71 70 63 байт

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

Спробуйте в Інтернеті!

Цей колодок Lз, NAпоки довжина не кратна b, потім приймає суми стовпців Lяк матрицю зі bстовпцями, видаляючи NAзначення.

Пояснення як мова на основі стека:

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

vi3$es

Спробуйте в Інтернеті! Або перевірити всі тестові випадки .

Пояснення

Розглянемо введення 4, в [0,3,7,2,5,1]якості прикладу.

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

Рубі , 54 53 байти

Збережено байт завдяки @Kirill L.

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

Спробуйте в Інтернеті!

C (gcc) , 107 байт

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

Спробуйте в Інтернеті!

Haskell , 61 байт

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

Спробуйте в Інтернеті!

Java 10, 96 89 86 байт

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

Спробуйте його онлайн тут .

Знайшов коротший спосіб написати i/(n/b+(n%b==0?0:1) тут: i/((n+b-1)/b)

Завдяки Олів'є Грегоаре за те, що він займався 3 байтами для гри в гольф.

Негольована версія:

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

Еліксир , 98 байт

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

Спробуйте в Інтернеті!

Найкращий Еліксир - це розщеплення на частини довжиною n . І воно не може дуже добре поділити поділ як ціле, тому ми робимо поплавковий поділ, округлюючи його. На жаль, єдиний спосіб зробити це приводить до поплавця, тому ми знову округлимо його до цілого числа.

Perl 6 ,  52 51  50 байт

52 байти: протестуйте

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

51 байт: протестуйте

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

50 байт: Спробуйте

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

47 байт не конкуруючий Тестуй це

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

Це не конкурує, як ».sumдозволяється робити розрахунки паралельно. Так що це може бути, а може і не бути в лінійному часі.

Розширено:

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

}

Вугілля деревне , 22 байти

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

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Пояснення:

Ｎθ

Вхідні дані b.

Ａη

Вхідні дані L.

Ｗ﹪Ｌηθ⊞η⁰

Натисніть 0на, Lпоки Lдовжина не поділиться на b.

Ｅ⪪η÷ＬηθＩΣι

Розділіть Lдовжину на bта розділіть Lна секції такої довжини, а потім підсумовуйте кожен розділ та передавайте на рядок для неявного виводу на окремі рядки.

JavaScript (Node.js) , 71 байт

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

Спробуйте в Інтернеті!

C (стук) , 58 байт

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

Спробуйте в Інтернеті!

f()приймає параметри так
L:: вказівник на масив введення
l: довжина вхідного масиву
b: кількість бін
m: вказівник на буфер, який отримує новий масив

Далі йде повторна версія @ 60 байт:

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

PHP, 88 байт

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

анонімна функція, приймає масив і ціле число, повертає масив

Тільки гра в гольф потенціал цього було заміняв ceil(count($a)/$b))з (count($a)-1)/$b+1і скороченим (count($a)-1)з ~-count($a). Отриманий поплавок неявно переноситься на ціле число у array_chunkвиклику.

Спробуйте в Інтернеті .