Bạn có một loạt các hộp nặng và bạn muốn xếp chúng trong số ít ngăn xếp nhất có thể. Vấn đề là bạn không thể xếp nhiều hộp trên một hộp hơn mức có thể hỗ trợ, vì vậy các hộp nặng hơn phải nằm ở dưới cùng của ngăn xếp.

Các thách thức

Đầu vào : Một danh sách các trọng lượng của hộp, tính bằng kg.

Đầu ra : Một danh sách các danh sách mô tả các ngăn xếp của hộp. Điều này phải sử dụng số lượng ngăn xếp ít nhất có thể cho đầu vào. Để là một ngăn xếp hợp lệ, trọng lượng của mỗi hộp trong ngăn xếp phải lớn hơn hoặc bằng tổng trọng lượng của tất cả các hộp phía trên nó.

Ví dụ về ngăn xếp hợp lệ

(Theo thứ tự từ dưới lên trên)

• [3]
• [1, 1]
• [3, 2, 1]
• [4, 2, 1, 1]
• [27, 17, 6, 3, 1]
• [33, 32, 1]
• [999, 888, 99, 11, 1]

Ví dụ về ngăn xếp không hợp lệ

(Theo thứ tự từ dưới lên trên)

• [1, 2]
• [3, 3, 3]
• [5, 5, 1]
• [999, 888, 777]
• [4, 3, 2]
• [4321, 3000, 1234, 321]

Ví dụ trường hợp kiểm tra

1

IN: [1, 2, 3, 4, 5, 6, 9, 12]
OUT: [[12, 6, 3, 2, 1], [9, 5, 4]]

2

IN: [87, 432, 9999, 1234, 3030]
OUT: [[9999, 3030, 1234, 432, 87]]

3

IN: [1, 5, 3, 1, 4, 2, 1, 6, 1, 7, 2, 3]
OUT: [[6, 3, 2, 1], [7, 4, 2, 1], [5, 3, 1, 1]]

4

IN: [8, 5, 8, 8, 1, 2]
OUT: [[8, 8], [8, 5, 2, 1]]

Quy tắc và giả định

• Quy tắc I / O tiêu chuẩn và sơ hở bị cấm áp dụng
• Sử dụng bất kỳ định dạng thuận tiện cho I / O
  • Ngăn xếp có thể được mô tả từ trên xuống dưới hoặc từ dưới lên trên, miễn là bạn nhất quán.
  • Thứ tự các ngăn xếp (chứ không phải các hộp trong các ngăn xếp đó) không quan trọng.
  • Bạn cũng có thể lấy các hộp đầu vào làm danh sách được chọn trước. Thứ tự không đặc biệt quan trọng đối với đầu vào, miễn là vấn đề chung không được giải quyết bằng cách tự sắp xếp.
• Nếu có nhiều hơn một cấu hình tối ưu của ngăn xếp, bạn có thể xuất bất kỳ một trong số chúng
• Bạn có thể cho rằng có ít nhất một hộp và tất cả các hộp nặng ít nhất 1 kg
• Bạn phải hỗ trợ trọng lượng tối đa 9,999 kg, tối thiểu.
• Bạn phải hỗ trợ tối đa 9,999 hộp, tối thiểu.
• Các hộp có cùng trọng lượng là không thể phân biệt, vì vậy không cần chú thích hộp nào đã được sử dụng ở đâu.

Chúc bạn chơi golf vui vẻ! Chúc may mắn!

Thạch , 19 byte

Œ!ŒṖ€ẎṖÄ>ḊƲ€¬ȦƊƇLÞḢ

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

Rõ ràng -3 nhờ Nick Kennedy ...

Từ trên xuống dưới.

Giải trình:

Œ!ŒṖ€ẎṖÄ>ḊƲ€¬ȦƊƇLÞḢ  Arguments: S (e.g. [1, 2, 3, 4, 5])
Œ!                   Permutations (e.g. [..., [4, 1, 5, 2, 3], ...])
    €                Map link over left argument (e.g. [..., [..., [[4, 1], [5], [2, 3]], ...], ...])
  ŒṖ                  Partitions (e.g. [..., [[4, 1], [5], [2, 3]], ...])
     Ẏ               Concatenate elements (e.g. [..., ..., [[4, 1], [5], [2, 3]], ..., ...])
               Ƈ     Filter by link (e.g. [..., [[1, 3], [2], [4], [5]], ...])
              Ɗ       Create >=3-link monadic chain (e.g. [[1], [], [0]])
           €           Map link over left argument (e.g. [[1], [], [0]])
          Ʋ             Create >=4-link monadic chain (e.g. [1])
      Ṗ                  Remove last element (e.g. [4])
       Ä                 Cumulative sum (e.g. [4])
         Ḋ               [Get original argument] Remove first element (e.g. [1])
        >                Greater than (vectorizes) (e.g. [1])
            ¬          Logical NOT (vectorizes) (e.g. [[0], [], [1]])
             Ȧ         Check if non-empty and not containing zeroes after flattening (e.g. 0)
                 Þ   Sort by link (e.g. [[[1, 2, 3], [4, 5]], ..., [[5], [4], [3], [2], [1]]])
                L     Length (e.g. 4)
                  Ḣ  Pop first element (e.g. [[1, 2, 3], [4, 5]])

JavaScript (Node.js),  139 122  116 byte

Mong đợi đầu vào được sắp xếp theo thứ tự tăng dần.

f=(A,s=[],[n,...a]=A,r)=>n?s.some((b,i,[...c])=>n<eval(b.join`+`)?0:f(A,c,a,c[i]=[n,...b]))?S:r?0:f(A,[...s,[]]):S=s

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

Đã bình luận

f = (                        // f is a recursive function taking:
  A,                         //   A[] = input array
  s = [],                    //   s[] = list of stacks, initially empty
  [n,                        //   n   = next weight to process
      ...a] = A,             //   a[] = array of remaining weights
  r                          //   r   = recursion flag
) =>                         //
  n ?                        // if n is defined:
    s.some((b, i,            //   for each stack b[] at position i in s[],
                  [...c]) => //   using c[] as a copy of s[]:
      n < eval(b.join`+`) ?  //     if n is not heavy enough to support all values in b[]:
        0                    //       abort
      :                      //     else:
        f(                   //       do a recursive call:
          A, c, a,           //         using A[], c[] and a[]
          c[i] = [n, ...b]   //         with n prepended to c[i]
        )                    //       end of recursive call
    ) ?                      //   end of some(); if successful:
      S                      //     return S[]
    :                        //   else:
      r ?                    //     if this is a recursive call:
        0                    //       do nothing
      :                      //     else:
        f(A, [...s, []])     //       try again with an additional stack
  :                          // else:
    S = s                    //   success: save the solution in S[]

Python 3.8 (tiền phát hành) , 178 byte

f=lambda b,s=[[]]:(a for i in range(len(s))if b[0]>=sum(s[i])for a in f(b[1:],s[:i]+[[b[0]]+s[i]]+s[i+1:]+[[]]))if b else[s]
g=lambda a:(c:=sorted(f(a),key=len)[0])[:c.index([])]

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

Bây giờ hoạt động trên tất cả các đầu vào có thể. (Nó xuất hiện trên TIO với hơn mười hộp hoặc hơn, nhưng nó tính toán một câu trả lời đúng)