specificazione

Questa sfida è semplice da dichiarare: il tuo input è un array non vuoto di numeri interi non negativi e il tuo compito è dividerlo in quante meno sottosequenze crescenti possibili. Più formalmente, se l'array di input è A, l'output è un array di array Btale che:

• Ciascuna Bforma in una partizione Ain sottosezioni disgiunte (non necessariamente contigue). Induttivamente, ciò significa che o Bè l'array singleton contenente A, o il primo elemento di Bè una sottosequenza di Ae il resto forma una partizione Acon quella sottosezione rimossa.
• Ogni array in B(non necessariamente strettamente) sta aumentando.
• Il numero di array in Bè minimo.

Sia l'input che l'output possono essere presi nel formato array nativo della tua lingua. Si noti che potrebbero esserci diverse uscite corrette.

Esempio

Considera l'array di input A = [1,2,1,2,5,4,7,1]. Un possibile output è B = [[1],[1,2,4,7],[1,2,5]]. La condizione di partizione è evidente da questo diagramma:

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

Inoltre, ogni array in Baumento. Infine, Anon può essere suddiviso in due sottosequenze crescenti, quindi anche la lunghezza di Bè minima. Quindi è un output valido.

Regole e punteggio

È possibile scrivere una funzione o un programma completo. Vince il conteggio di byte più basso e non sono consentite scappatoie standard. Non vi è alcun limite di tempo, ma è necessario valutare la soluzione su tutti i casi di test prima di inviarlo.

Casi test

Viene mostrato un solo output possibile, ma potrebbero esserci diverse opzioni valide. In particolare, l'ordine degli array nel risultato non ha importanza (ma ogni singolo array dovrebbe essere in ordine 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 byte

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

Esempio di utilizzo: foldr(#)[] [4,12,2,10,15,2,2,19,16,12]->[[2,2,2,12],[4,10,15,16],[12,19]]

Come funziona: scorrere l'elenco di input a partire dall'estremità destra. Crea l'elenco di output (di elenchi) anteponendo l'elemento corrente nal primo elenco secondario ldove nè minore o uguale alla testa di l. Se non ce ne sono, crea un nuovo elenco singleton nalla fine dell'elenco di output.

Pyth, 20 byte

fTu&ahfSI+THGHGQm[)Q

Provalo online: dimostrazione o suite di test

Approccio avido. Creo len(input)liste vuote. Quindi eseguo l'iterazione su ciascun numero in inputan scegli il primo elenco, che viene comunque ordinato dopo aver aggiunto il numero.

Spiegazione:

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