In questa semplice sfida ti viene dato un array Ldi input di numeri interi non negativi e un numero di bin bmaggiore di 0 ma non superiore alla lunghezza di L. Il codice deve restituire un nuovo array la Mcui lunghezza è be che ha vincolato l'array L. Questo è più semplice spiegato con esempi.

L = [1,0,5,1]e b = 2ritorna M = [1,6].

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

Finora così semplice. Tuttavia, in questa domanda bnon è necessario dividere necessariamente len(L). In questo caso l'ultimo cestino avrà solo un minor numero di numeri per inventarlo.

Ogni bin tranne forse l'ultimo deve avere lo stesso numero di numeri che contribuiscono al suo totale. L'ultimo cestino non deve contenere più numeri rispetto agli altri bin. L'ultimo cestino deve avere il maggior numero possibile di contributi in base alle altre regole.

L = [0,3,7,2,5,1]e b = 4ritorna M = [3,9,6,0]. M = [10,8,0,0]non è un output accettabile in quanto il terzo bin non ha il nome numero di numeri che vi contribuiscono come bin 1e 2.

L = [0,3,7,2,5]e b = 2ritorna M = [10,7]. M = [3, 14]non è un output accettabile poiché l'ultimo bin avrà 3elementi che contribuiscono ad esso, ma il primo ha solo 2.

L = [1,1,1,1,1,1,1]e b = 3ritorna M = [3,3,1].

Come regola finale, il codice deve essere eseguito in tempo lineare.

È possibile utilizzare qualsiasi lingua o libreria che ti piace e puoi presumere che l'input sia fornito in qualsiasi modo ritieni opportuno.

Si scopre che ci sono alcuni input che non possono essere risolti. Ad esempio [1,1,1,1,1]e b=4. Il tuo codice può generare qualsiasi cosa gli piaccia per quegli input.

APL (Dyalog) , 19 byte

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

Provalo online!

Aggiungiamo zeri b all'array prima di rimodellarlo in parti uguali di ⌈⍺÷⍨≢⍵( ⌈ lunghezza di L ÷ b ⌉ ) e sommarli , come rappresentato in ,⍺⍴0, poiché qualsiasi quantità di punti vuoti (che non fanno parte dell'array originale) più grande di b - 1 verrebbe riempito con almeno b - 1 elementi di altri blocchi, il che rende il punto di bilanciamento dell'ultimo gruppo al massimo b - 1 differenza dal resto. Usiamo b> b - 1 perché si tratta di codice golf.

Ad esempio, L con 15 elementi e b = 3 non verrebbero raggruppati come

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

ma piuttosto come (notare come i 2 xs più a destra "riempiono" gli zeri più a sinistra)

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

mentre un array di 16 elementi verrebbe riempito con 2 ( 3 - 1 ) punti vuoti, come

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

Provalo online!

R , 75 71 70 63 byte

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

Provalo online!

Questo pad Lcon NAfino a quando la lunghezza è un multiplo di b, quindi prende le somme delle colonne Lcome una matrice con le bcolonne, rimuovendo i NAvalori.

Spiegazione come linguaggio basato su stack:

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

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

Considera l'input 4, [0,3,7,2,5,1]come esempio.

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

Rubino , 54 53 byte

Salvataggio di un byte grazie a @Kirill L.

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

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

Provalo online!

Haskell , 61 byte

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

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

Provalo online qui .

Trovato un modo più breve per scrivere i/(n/b+(n%b==0?0:1) qui: i/((n+b-1)/b)

Grazie a Olivier Grégoire per il golf 3 byte.

Versione non golfata:

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

Elisir , 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

Provalo online!

Il miglior elisir ha è la divisione in parti con una lunghezza di n . E non può cementare molto bene la divisione come intero, quindi eseguiamo la divisione float, arrotondandola per eccesso. Sfortunatamente l'unico modo per farlo si traduce in un float, quindi lo arrotondiamo nuovamente a un numero intero.

Perl 6 ,  52 51  50 byte

52 byte: testalo

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

51 byte: testalo

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

50 byte: provalo

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

47 byte non competitivi Provalo

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

Non è in competizione poiché ».sumè consentito eseguire i calcoli in parallelo. Quindi potrebbe essere o meno in tempo lineare.

Allargato:

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

}

Carbone , 22 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｎθ

Input b.

Ａη

Input L.

Ｗ﹪Ｌηθ⊞η⁰

Premere 0a Lfino a quando Lla lunghezza è divisibile per b.

Ｅ⪪η÷ＬηθＩΣι

Dividi Lla lunghezza be dividi Lin sezioni di quella lunghezza, quindi somma ogni sezione e esegui il cast in stringa per un output implicito su linee separate.

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

Provalo online!

C (clang) , 58 byte

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

Provalo online!

f()accetta i parametri come segue::
Lpuntatore all'array di input
l: lunghezza dell'array di input
b: numero di bin
m: puntatore al buffer che riceve un nuovo array

Di seguito è riportata una versione di rientro a 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];}

funzione anonima, accetta array e intero, restituisce array

Il potenziale unico golf questo ha avuto è stata la sostituzione ceil(count($a)/$b))con (count($a)-1)/$b+1e abbreviando (count($a)-1)con ~-count($a). Il float risultante viene implicitamente castato in numero intero nella array_chunkchiamata.

Provalo online .