Sự chỉ rõ

Thách thức này rất đơn giản để nêu rõ: đầu vào của bạn là một mảng không chứa các số nguyên không âm, và nhiệm vụ của bạn là phân vùng nó thành càng ít chuỗi càng tốt. Chính thức hơn, nếu mảng đầu vào là A, thì đầu ra là một mảng các mảng Bsao cho:

• Mỗi mảng trong Bmột phân vùng Athành các chuỗi khác nhau (không nhất thiết phải liền kề). Theo cách tự nhiên, điều này có nghĩa là một trong Bcác mảng đơn có chứa A, hoặc phần tử đầu tiên Blà một phần tiếp theo Avà phần còn lại tạo thành một phân vùng Avới phần tiếp theo được loại bỏ.
• Mỗi mảng trong B(không nhất thiết phải nghiêm ngặt) tăng lên.
• Số lượng các mảng trong Blà tối thiểu.

Cả đầu vào và đầu ra đều có thể được lấy ở định dạng mảng gốc của ngôn ngữ của bạn. Lưu ý rằng có thể có một số đầu ra chính xác.

Thí dụ

Hãy xem xét các mảng đầu vào A = [1,2,1,2,5,4,7,1]. Một đầu ra có thể là B = [[1],[1,2,4,7],[1,2,5]]. Điều kiện phân vùng là rõ ràng từ sơ đồ này:

A    1 2 1 2 5 4 7 1
B[0]               1
B[1] 1 2       4 7
B[2]     1 2 5

Ngoài ra, mỗi mảng trong Bđang tăng lên. Cuối cùng, Akhông thể chia thành hai phần tăng dần, vì vậy độ dài Bcũng là tối thiểu. Vì vậy, nó là một đầu ra hợp lệ.

Quy tắc và tính điểm

Bạn có thể viết một chức năng hoặc một chương trình đầy đủ. Số byte thấp nhất sẽ thắng và các sơ hở tiêu chuẩn không được phép. Không có thời gian ràng buộc, nhưng bạn nên sơ tán giải pháp của mình trên tất cả các trường hợp thử nghiệm trước khi gửi nó.

Các trường hợp thử nghiệm

Chỉ có một đầu ra có thể được hiển thị, nhưng có thể có một số tùy chọn hợp lệ. Cụ thể, thứ tự của các mảng trong kết quả không thành vấn đề (nhưng mỗi mảng riêng lẻ phải theo thứ tự tăng dần).

[0] -> [[0]]
[3,5,8] -> [[3,5,8]]
[2,2,2,2] -> [[2,2,2,2]]
[1154,1012,976,845] -> [[845],[976],[1012],[1154]]
[6,32,1,2,34,8] -> [[1,2,8],[6,32,34]]
[1,12,1,12,1,13] -> [[1,1,1,13],[12,12]]
[6,4,6,13,18,0,3] -> [[0,3],[4,6,13,18],[6]]
[1,2,3,2,3,4,7,1] -> [[1,1],[2,2,3,4,7],[3]]
[0,9,2,7,4,5,6,3,8] -> [[0,2,3,8],[4,5,6],[7],[9]]
[7,1,17,15,17,2,15,1,6] -> [[1,1,6],[2,15],[7,15,17],[17]]
[4,12,2,10,15,2,2,19,16,12] -> [[2,2,2,12],[4,10,15,16],[12,19]]
[10,13,9,2,11,1,10,17,19,1] -> [[1,1],[2,10,17,19],[9,11],[10,13]]
[3,7,3,8,14,16,19,15,16,2] -> [[2],[3,3,8,14,15,16],[7,16,19]]
[15,5,13,13,15,9,4,2,2,17] -> [[2,2,17],[4],[5,9],[13,13,15],[15]]

Haskell, 54 byte

n#[]=[[n]]
n#(l:c)|[n]<=l=(n:l):c|1<2=l:n#c
foldr(#)[]

Ví dụ sử dụng: foldr(#)[] [4,12,2,10,15,2,2,19,16,12]->[[2,2,2,12],[4,10,15,16],[12,19]]

Cách thức hoạt động: đi qua danh sách đầu vào bắt đầu ở cuối bên phải. Xây dựng danh sách đầu ra (của danh sách) bằng cách thêm phần tử hiện tại nvào danh sách con đầu tiên ltrong đó nnhỏ hơn hoặc bằng đầu l. Nếu không có, tạo một danh sách đơn mới nở cuối danh sách đầu ra.

Bình thường, 20 byte

fTu&ahfSI+THGHGQm[)Q

Dùng thử trực tuyến: Trình diễn hoặc Test Suite

Cách tiếp cận tham lam. Tôi tạo len(input)danh sách trống. Sau đó, tôi lặp lại từng số trong inputdanh sách chọn đầu tiên, danh sách này vẫn được sắp xếp sau khi nối thêm số đó.

Giải trình:

fTu&ahfSI+THGHGQm[)Q   implicit: Q = input list
                m[)Q   create a list of empty lists and assign to G
  u            Q       iterate over all numbers H in input:
      f     G             filter for lists T in G, which satisfy:
         +TH                 create a new list out of T and H
       SI                    and check if it is sorted
     h                    take the first such list T
    a        H            and append H
   &          G           logical and with G (so that u doesn't overwrite G)
fT                     remove all empty lists