Especificação

Esse desafio é simples de declarar: sua entrada é uma matriz não vazia de números inteiros não negativos e sua tarefa é particioná-la no menor número possível de subsequências possíveis. Mais formalmente, se a matriz de entrada for A, a saída será uma matriz de matrizes, Btais como:

• Cada matriz Bforma uma partição de Asubseqüências disjuntas (não necessariamente contíguas). Indutivamente, isso significa que ou Ba matriz singleton contém Aou o primeiro elemento de Bé uma subsequência de Ae o restante forma uma partição Acom a subsequência removida.
• Cada matriz Bestá (não necessariamente estritamente) aumentando.
• O número de matrizes Bé mínimo.

Tanto a entrada quanto a saída podem ser obtidas no formato de matriz nativa do seu idioma. Observe que pode haver várias saídas corretas.

Exemplo

Considere a matriz de entrada A = [1,2,1,2,5,4,7,1]. Uma saída possível é B = [[1],[1,2,4,7],[1,2,5]]. A condição da partição é evidente neste diagrama:

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

Além disso, cada matriz Bestá aumentando. Finalmente, Anão pode ser dividido em duas subsequências crescentes, portanto, o comprimento de Btambém é mínimo. Portanto, é uma saída válida.

Regras e pontuação

Você pode escrever uma função ou um programa completo. A menor contagem de bytes vence e as brechas padrão não são permitidas. Não há limite de tempo, mas você deve avaliar sua solução em todos os casos de teste antes de enviá-la.

Casos de teste

Apenas uma saída possível é mostrada, mas pode haver várias opções válidas. Em particular, a ordem das matrizes no resultado não importa (mas cada matriz individual deve estar em ordem crescente).

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

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

Exemplo de uso: foldr(#)[] [4,12,2,10,15,2,2,19,16,12]->[[2,2,2,12],[4,10,15,16],[12,19]]

Como funciona: percorra a lista de entradas começando pelo lado direito. Crie a lista de saída (de listas), acrescentando o elemento atual nà primeira sub-lista, londe né menor ou igual ao cabeçalho de l. Se não houver, faça uma nova lista de singleton nno final da lista de saída.

Pitão, 20 bytes

fTu&ahfSI+THGHGQm[)Q

Experimente on-line: Demonstration or Test Suite

Abordagem gananciosa. Eu crio len(input)listas vazias. Em seguida, iteramos sobre cada número na lista inpute escolha a primeira, que ainda é classificada após o acréscimo do número.

Explicação:

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