Há um "algoritmo de classificação", às vezes chamado classificação Stalin, no qual, para classificar uma lista, você simplesmente remove elementos da lista até que ela seja classificada em ordem crescente. Por exemplo, a lista

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

Quando "classificado" usando a classificação Stalin se torna

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

Os três foram removidos porque estavam fora de ordem.

Agora, obviamente, existem muitas maneiras de remover elementos para classificar uma lista. Por exemplo, qualquer lista com menos de dois elementos deve ser classificada; portanto, basta remover elementos suficientes cegamente, sempre podemos classificar uma lista. Como esse é o caso, nos preocupamos apenas com o resultado mais longo possível de um tipo de Stalin.

Sua tarefa será pegar uma lista de números inteiros positivos e gerar o comprimento da lista classificada mais longa (crescente) que pode ser alcançada removendo elementos da lista original. É o comprimento da sub-lista classificada mais longa (possivelmente não contígua).

As listas ordenadas podem ter o mesmo elemento mais de uma vez em uma linha. Você não precisa oferecer suporte à lista vazia, a menos que seu próprio programa esteja vazio.

Pontuação

Sua resposta será pontuada pelo tamanho de sua própria classificação Stalin mais longa possível. Os programas serão interpretados como uma sequência de bytes em vez de caracteres, e sua ordem será a ordem natural que surgir ao interpretar os bytes como números. Pontuações mais baixas são melhores.

Este não é um código de golfe

Aqui está uma ferramenta simples para ajudá-lo a obter suas respostas.

Casos de teste

[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 , comprimento 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))

A saída é via código de saída.

Experimente online!

Como funciona

A todo momento, a matriz $L$ controla os subarrays classificados mais longos encontrados até agora; $L[a-1]$ é o comprimento do mais longo que termina com $a$ .

Inicialmente, não processamos os elementos de uma matriz, portanto $L$ consiste inteiramente em zeros.

$a$$[L[0], \dots, L[a-1]]$$a$$a$$a$$L[a-1]$

$L$

Wolfram Language (Mathematica) , pontuação 9

Length@*LongestOrderedSequence

Experimente online!

Perl 6 , 9 pontos

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

Experimente online!

Haskell , Pontuação 8 7, 48 bytes

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

Experimente online!

A sub-lista classificada mais longa é

%%%%%%)

Gelatina , comprimento  4  2

ṢƑƇZLƲ}ŒP

Experimente online!

Bytes na página de códigos de Jelly

183 146 144 90 76 169 125 19 80

Como funciona

ṢƑƇ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.

Pitão, pontuação 3 2 ( 7 bytes)

leSI#y

Guardou um ponto graças ao Anders Kaseorg.
Experimente aqui

Explicação

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 comprimento máximo tipo stalin

S{:^fF%|M

Execute e depure

Funciona assim.

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

R , Pontuação 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)}

Experimente online!

Portos Resposta de Python de Dennis para R.

Brachylog , comprimento 2 (4 bytes)

⊇≤₁l

Experimente online!

Uma resposta que compensa ser tão concisa por não ser muito mais curta.

( 08 03 80 6Cna página de códigos de Brachylog)

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