Esiste un "algoritmo di ordinamento" a volte chiamato ordinamento Stalin in cui per ordinare un elenco è sufficiente rimuovere gli elementi dall'elenco fino a quando non viene ordinato in ordine crescente. Ad esempio l'elenco

[1, 2, 4, 5, 3, 6, 6]

Quando "ordinato" utilizzando Stalin l'ordinamento diventa

[1, 2, 4, 5, 6, 6]

I tre furono rimossi perché erano fuori servizio.

Ora ovviamente ci sono molti modi per rimuovere elementi per ordinare un elenco. Ad esempio, qualsiasi elenco con meno di due elementi deve essere ordinato, quindi rimuovendo ciecamente abbastanza elementi ci si può sempre ordinare un elenco. Dal momento che questo è il caso, ci preoccupiamo solo del risultato più lungo possibile di un tipo Stalin.

Il tuo compito sarà quello di prendere un elenco di numeri interi positivi e produrre la lunghezza dell'elenco (crescente) più lungo ordinato che può essere ottenuto rimuovendo elementi dall'elenco originale. Cioè trova la lunghezza della sotto-lista ordinata più lunga (possibilmente non contigua).

Gli elenchi ordinati possono avere lo stesso elemento più di una volta di fila. Non è necessario supportare l'elenco vuoto a meno che il programma stesso non sia vuoto.

punteggio

La tua risposta verrà valutata in base alla lunghezza del suo ordinamento Stalin più lungo possibile. I programmi saranno interpretati come una sequenza di byte anziché come caratteri, e il loro ordine sarà quello naturale che sorgerà interpretando i byte come numeri. I punteggi più bassi sono migliori.

Questo non è code-golf

Ecco uno strumento accurato per aiutarti a segnare le tue risposte.

Casi test

[1, 2, 4, 5, 3, 6, 6] -> 6
[19, 2] -> 1
[3, 3, 4, 3] -> 3
[10] -> 1
[1, 2, 4, 9] -> 4
[1, 90, 2, 3, 4, 5] -> 5
[1, 90, 91, 2, 3, 4, 5] -> 5

Python 2 , lunghezza 14 12 10 9

M=max;X=exit;i=input();L=[0]*M(i)
for	a	in	i:L[a-1]=M(L[:a])+1
X(M(L))

L'uscita è tramite il codice di uscita.

Provalo online!

Come funziona

$L$$L[a-1]$$a$ .

$L$

$a$$[L[0], \dots, L[a-1]]$, which is length of the longest sorted subarray encountered so far that ends with $a$ or a smaller integer. Appending $a$ to such an array will keep it sorted, so the longest sorted subarray ending in $a$ is one element longer than that maximum. We update $L[a-1]$ with the computed value.

The final result is the maximum of $L$.

Wolfram Language (Mathematica), score 9

Length@*LongestOrderedSequence

Try it online!

Perl 6, score 9

*.combinations.map({@^a*[<=] @a}).max

Try it online!

Haskell, Score 8 7, 48 bytes

(l:k)%d|d>l=k%d|3>2=max(1+k%l)(k%d)
c%b=0
a=(%0)

Try it online!

The longest sorted sublist is

%%%%%%)

Jelly, length  4  2

ṢƑƇZLƲ}ŒP

Try it online!

Bytes in Jelly's code page

183 146 144 90 76 169 125 19 80

How it works

ṢƑƇZLƲ}ŒP  Main link. Argument: A (array)

       ŒP  Powerset; yield P, the array of all sub-arrays of A.
     Ʋ     Vier; combine the preceding four links into a monadic chain...
      }    and apply the chain to the right argument (P).
  Ƈ            Comb; only keep arrays for which the link to the left returns 1.
ṢƑ             Sort fixed; yield 1 if sorting doesn't alter the array.
   Z           Zip; read the filtered powerset by columns.
    L          Take the length.

Pyth, score 3 2 (7 bytes)

leSI#y

Saved a point thanks to Anders Kaseorg.
Try it here

Explanation

leSI#y
     yQ    Take the power set of the (implicit) input (preserving order).
  SI#      Get the ones that are sorted.
 e         Take the last (longest).
l          Get the length.

Stax, 4 maximal length stalin sort

S{:^fF%|M

Run and debug it

It works like this.

S       powerset of input
{:^f    filter by non-descending sequences
F%|M    take the maximum length remaining

R, Score 15 11, 72 62 bytes

function(L,M=max,A=1:M(L)*0){for(Y in L)A[Y]=M(A[1:Y])+1;M(A)}

Try it online!

Ports Dennis' Python answer to R.

Brachylog, length 2 (4 bytes)

⊇≤₁l

Try it online!

An answer which makes up for being so concise by not being that much shorter sorted.

(08 03 80 6C in Brachylog's code page)

        Output
   l    the length of
 ≤₁     a non-decreasing
⊇       sublist of
        the input.
        (maximizing the size of the sublist)