Специфікація

Цей виклик простий у формулюванні: ваш вхід - це не порожній масив негативних цілих чисел, і ваше завдання полягає в тому, щоб розділити його на якомога менше збільшуваних підрядів. Більш формально, якщо вхідний масив є A, то вихід є масивом масивів Bтаким чином:

• Кожен масив Bформує розділ Aна неперервні (не обов'язково суміжні) підпорядкування. Індуктивно це означає, що або Bє однотонний масив, що містить A, або перший елемент з Bявляє собою Aпідпорядкування, а решта утворюють розділ, Aз яким видаляється підпорядкованість .
• Кожен масив у B(не обов'язково суворо) збільшується.
• Кількість масивів у Bмінімальна.

І введення, і вихід можуть бути зроблені у форматі рідного масиву вашої мови. Зверніть увагу, що може бути кілька правильних виходів.

Приклад

Розглянемо вхідний масив A = [1,2,1,2,5,4,7,1]. Один з можливих результатів - це B = [[1],[1,2,4,7],[1,2,5]]. Умова розділу видно на цій схемі:

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

Також кожен масив у Bзбільшується. Нарешті, Aне можна розділити на дві зростаючі послідовності, тому довжина Bтакож мінімальна. Таким чином, це дійсний вихід.

Правила та оцінка

Ви можете написати функцію або повну програму. Виграє найнижчий байт, а стандартні лазівки заборонені. Час не обмежений, але перед тим, як подавати його, слід евакуювати рішення щодо всіх тестових випадків.

Тестові справи

Показано лише один можливий вихід, але може бути кілька дійсних варіантів. Зокрема, порядок масивів у результаті не має значення (але кожен окремий масив повинен бути у порядку зростання).

[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 байти

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

Приклад використання: foldr(#)[] [4,12,2,10,15,2,2,19,16,12]->[[2,2,2,12],[4,10,15,16],[12,19]]

Як це працює: перегляньте список вводу, починаючи з правого кінця. Створіть вихідний список (списків), попередньо додавши поточний елемент nдо першого підспілу, lде nменше або дорівнює заголовку l. Якщо його немає, складіть новий однотонний список nв кінці списку вихідних даних.

Pyth, 20 байт

fTu&ahfSI+THGHGQm[)Q

Спробуйте в Інтернеті: Демонстрація або Тестовий набір

Жадібний підхід. Я створюю len(input)порожні списки. Потім я повторюю кожне число у списку inputвибору першого, який все ще сортується після додавання номера.

Пояснення:

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