이 간단한 도전에서는 L음수가 아닌 정수와 b0보다 길지만 길이가 아닌 빈 의 입력 배열이 제공 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 의 등분을 재 형성하기 전에 어레이 0을 ⌈⍺÷⍨≢⍵( ⌈ ⌉ B ÷ L의 길이 에 도시 됨)과, 이들을 합산 ,⍺⍴0보다 큰 (일본어 어레이의 일부가 아닌) 빈 공간의 임의의 양 때문에, B -1 은 다른 청크의 b-1 개 이상의 원소 로 채워져 마지막 그룹의 밸런싱 포인트가 나머지 그룹과 최대 b-1 차이가되게합니다. 코드 골프이기 때문에 b> b-1을 사용 합니다.

예를 들어, 요소 가 15 개이고 b = 3 인 L은 다음 과 같이 그룹화되지 않습니다.

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

그러나 오히려 (가장 오른쪽 2 x초가 가장 왼쪽 0을 채우는 방법에 유의하십시오 )

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

잠시 16 개 요소 어레이가 채워질 것이다 2 ( 1 - 3 ) 빈 공간처럼

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

파이썬 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;}

온라인으로 사용해보십시오!

하스켈 , 61 바이트

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

온라인으로 사용해보십시오!

자바 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 바이트 골프를 한 Olivier Grégoire에게 감사드립니다.

언 골프 버전 :

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

온라인으로 사용해보십시오!

최고의 Elixir는 길이가 n 인 파트로 분할됩니다 . 그리고 그것은 정수로 나누기를 잘 할 수 없으므로 float 나누기를하고 반올림하십시오. 불행히도이 작업을 수행하는 유일한 방법은 부동 소수점을 초래하므로 정수로 다시 반올림합니다.

펄 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.

Ｗ﹪Ｌηθ⊞η⁰

길이를 나눌 수 있을 때까지 a 0를 누릅니다 .LLb

Ｅ⪪η÷ＬηθＩΣι

L의 길이를 나누고 해당 길이의 섹션으로 b나눈 L다음 각 섹션을 합산하고 별도의 줄에 암시 적 출력을 위해 문자열로 캐스트합니다.

자바 스크립트 (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). 결과 float은 암시 적으로 array_chunk호출 에서 정수로 캐스트됩니다 .

온라인으로 사용해보십시오 .