ในการท้าทายแบบนี้คุณจะได้รับการป้อนข้อมูลอาร์เรย์Lของจำนวนเต็มไม่เป็นลบและจำนวนของถังขยะbมากกว่า 0 Lแต่ไม่เกินความยาวของ รหัสของคุณจะต้องส่งคืนอาเรย์ใหม่Mที่มีความยาวbและอาเรย์Lนั้นได้ถูกรวมเข้าด้วยกัน นี่คือตัวอย่างที่อธิบายได้ง่ายที่สุด

L = [1,0,5,1]และผลตอบแทนb = 2M = [1,6]

L = [0,3,7,2,5,1]และผลตอบแทนb = 3M = [3,9,6]

จนถึงตอนนี้ง่ายมาก อย่างไรก็ตามในคำถามนี้ไม่จำเป็นต้องมีการแบ่งb len(L)ในกรณีนี้ถังขยะสุดท้ายจะมีตัวเลขน้อยกว่าในการสร้าง

แต่ละ bin ยกเว้นอาจเป็นอันสุดท้ายต้องมีจำนวนตัวเลขเท่ากันซึ่งมีผลต่อจำนวนทั้งหมด ถังขยะสุดท้ายจะต้องไม่มีตัวเลขที่มีส่วนร่วมมากกว่าถังขยะอื่น ถังขยะสุดท้ายจะต้องมีตัวเลขจำนวนมากที่มีส่วนร่วมให้มากที่สุดภายใต้กฎอื่น ๆ

L = [0,3,7,2,5,1]และผลตอบแทน b = 4 ไม่ได้มีการส่งออกได้รับการยอมรับว่าเป็นถังที่สามไม่ได้มีจำนวนชื่อของตัวเลขที่เอื้อต่อการเป็นถังขยะและM = [3,9,6,0]M = [10,8,0,0]12

L = [0,3,7,2,5]และผลตอบแทน b = 2 ไม่ได้มีการส่งออกได้รับการยอมรับว่าเป็นถังที่ผ่านมาจะมีองค์ประกอบที่เอื้อต่อการได้ แต่ครั้งแรกที่มีเพียงM = [10,7]M = [3, 14]32

L = [1,1,1,1,1,1,1]และผลตอบแทนb = 3M = [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 xs ขวาสุด"เติมใน" ศูนย์ซ้ายสุด)

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

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

ขอบคุณ Olivier Grégoireสำหรับการเล่นกอล์ฟขนาด 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;
}

Elixir , 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จนถึงระยะเวลาของการหารด้วยLb

Ｅ⪪η÷ＬηθＩΣι

หาร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และ abbreviating กับ(count($a)-1) ~-count($a)ทุ่นที่เกิดขึ้นจะถูกส่งไปยังจำนวนเต็มโดยนัยในการarray_chunkโทร

ลองมันออนไลน์