Esse desafio já descreve o dropsort. No entanto, sou meio preguiçoso e realmente só preciso que minha matriz seja um pouco mais ordenada do que antes, não precisa ser ordenada completamente .

No Drop Sort, eliminamos cada elemento menos que qualquer elemento anterior a ele. No Lazy Drop Sort, eliminamos todos os elementos menos do que o estritamente anterior .

Aqui está um exemplo. Considere a seguinte matriz:

8 6 9 9 7 2 3 8 1 3

Vamos marcar cada elemento menor que o anterior.

8 6 9 9 7 2 3 8 1 3
  ^     ^ ^     ^

Observe como nem 3foi marcado nem o último 8. Eles são todos maiores que o elemento único à esquerda deles.

Completando o algoritmo, removendo os elementos marcados, obtemos:

8 9 9 3 8 3

Isso basicamente parece mais organizado. Meio. Sou preguiçosa.

Sua tarefa, como você já deve ter deduzido, é implementar esse algoritmo.

A entrada é uma matriz de pelo menos 1 número inteiro positivo entre 1 e 9, para que você também possa pegar uma sequência de dígitos.

Isso é código-golfe , o menor número de bytes vence!

Casos de teste adicionais:

1
1

1 2 3
1 2 3

5 3 1
5

1 2 3 2 1
1 2 3

1 1 1 9 9 9 1 1 1 9 9 9 1 1 1
1 1 1 9 9 9 1 1 9 9 9 1 1

9 9
9 9

5 2 4 2 3
5 4 3

Casca , 4 bytes

m←ġ<

Experimente online!

Explicação

m←ġ<
  ġ<    Group the numbers into decreasing sequences
m←      Keep the first element of each sequence

JavaScript (ES6), 28 25 bytes

Guardado 3 bytes graças a @Shaggy

a=>a.filter(n=>~-a<(a=n))

Experimente online!

R , 27 bytes

(l=scan())[c(T,diff(l)>=0)]

Experimente online!

MATL , 9 8 bytes

Guardou um byte graças a Giuseppe.

0yd0<h~)

Experimente online!

Explicação:

0                 % Push a zero
 y                % Implicitly grab the input and duplicate it.
                  % Stack: [8 6 9 9 7 2 3 8 1 3], 0, [8 6 9 9 7 2 3 8 1 3]
  d               % The difference between each number of the last element:
                  % Stack: [8 6 9 9 7 2 3 8 1 3], 0, [-2, 3, 0, -2, -5, 1, 5, -7, 2]
   0<             % Which are negative?
                  % Stack: [8 6 9 9 7 2 3 8 1 3], 0, [1 0 0 1 1 0 0 1 0]
     h            % Concatenate. Stack: [8 6 9 9 7 2 3 8 1 3], [0 1 0 0 1 1 0 0 1 0] 
      ~           % Negate. Stack: [8 6 9 9 7 2 3 8 1 3], [1 0 1 1 0 0 1 1 0 1]
       )          % Index. Stack: [8 9 9 3 8 3]

Perl 5 .10.0 + -nl, 16 bytes

$f>$_||say;$f=$_

Experimente online!

Haskell, 29 bytes

f s=[b|(a,b)<-zip(0:s)s,a<=b]

apenas uma simples compreensão da lista.

Japonês , 8 7 bytes

Guardado 1 byte graças a @Oliver

k@>(U=X

Teste online!

Alternativas:

f@T§(T=X
k@ä>0 gY
i0 ò> mÅ c

Stax , 5 bytes

âÿ╠╦░

Execute e depure isso online

Ao descompactar, desfeitar e comentar o código, obtemos isso.

Z   Push a zero under the input
f   Use the rest of the program as a filter on the input.  Output passing elements.
>   Current element is greater than previous?
_~  Push current element to the input stack; when the main stack is empty, pops fall back to this
!   Logical not; applies to the result of the greater-than

Execute este

A ordem das instruções é incômoda, mas há uma razão para isso. A embalagem do código fonte Stax nem sempre produz o mesmo tamanho de saída para a mesma entrada de tamanho. Basicamente, você tem a chance de salvar um byte se o último caractere da fonte tiver um código de caractere mais baixo. Bem, !tem um dos códigos mais baixos que você pode obter para um caractere imprimível. (33 especificamente) Muitos programas stax ASCII de 6 bytes não podem ser menores. Mas se eles terminam com a !, podem. Portanto, o motivo dessa ordem específica de instruções é garantir que o lógico não termine no final do programa.

J, 12 bytes

#~1,2&(<:/\)

Explicação:

#~1,2&(<:/\)    | Whole function, executed as a hook
       <:/      | Distribute <: (greater or equal) over an array
    2&(   \)    | Apply to each sub array of length 2
  1,            | Append a 1 to the front
#~              | Choose elements from the original array

Exemplos:

    2&(<:/\) 8 6 9 9 7 2 3 8 1 3
0 1 1 0 0 1 1 0 1
    1,2&(<:/\) 8 6 9 9 7 2 3 8 1 3
1 0 1 1 0 0 1 1 0 1
    (1 0 1 1 0 0 1 1 0 1) # 8 6 9 9 7 2 3 8 1 3
8 9 9 3 8 3
    f =: #~1,2&(<:/\)
    f 8 6 9 9 7 2 3 8 1 3
8 9 9 3 8 3

Experimente online!

Gelatina , 6 bytes

>Ɲ0;¬×

A E / S está em cadeias.

Experimente online!

Java 8, 66 55 48 bytes

l->{for(int i=0;;)if(i>(i=l.next()))l.remove();}

-11 bytes após uma dica de @ OlivierGrégoire .
-7 mais bytes graças a @ OlivierGrégoire .

Explicação:

Experimente online.

l->{                     // Method with Integer-ListIterator parameter and no return-type
  for(int i=0;;)         //  Loop over all items
    if(i>(i=l.next()))   //   If the current item is larger than the next
      l.remove();}       //    Remove this next item

Oitava , 21 bytes

@(x)x(~[0,diff(x)<0])

Experimente online!

Explicação:

Pegue um vetor xcomo entrada e crie um vetor [0, diff(x)<0], onde diff(x)é um vetor com a diferença entre todos os elementos adjacentes. Mantenha apenas os negativos comparando-os a zero, fornecendo uma lista de todos os elementos que queremos eliminar.

Em seguida, selecionamos os elementos do vetor de entrada que queremos manter.

V , 25 bytes

òjälá k$yl+@"òç-/d
ç /dw

Experimente online!

Hexdump:

00000000: f26a e46c e120 6b24 796c 2b40 2218 f2e7  .j.l. k$yl+@"...
00000010: 2d2f 640a e720 2f64 77                   -/d.. /dw

Pior idioma para o trabalho. Mas fiz isso por um desafio .

Triangularidade , 71 bytes

.....).....
....IEL....
...)rFD)...
..2+)IE)w..
.+h)2_stDO.
={M)IEm}...

Experimente online!

Como funciona?

) IEL) rFD) 2+) IE) w + h) 2_stDO = {M) IEm} - Programa completo.
) IE - Obtenha a 0ª entrada I e avalie-a.
   L) r - E pressione o intervalo [0 ... comprimento de I).
      F {- Filtre os números inteiros neste intervalo que satisfazem:
       D) 2+) IE) w + h) 2_stDO = - Esta condição. Executa cada elemento E em um separado
                                    empilhar e descartar aqueles que não atendem aos critérios.
       D) 2+ - Duplique e adicione 2 à segunda cópia.
           ) IE - Recupere I novamente.
              ) - Empurre um 0 para a pilha.
               w - Coloque o 0 em uma lista. [0]
                + - Anexe-o a I.
                 h - cabeça. Apare os elementos após o índice E + 2.
                  ) 2_ - Literal -2.
                     st - cauda.
                       DO = - Verifique se o resultado é invariável sobre a classificação.
                           M) IEm} - Última parte: indexação na entrada.
                           M} - Para cada índice que satisfaça as condições:
                            ) IEm - Recupere o elemento I nessa posição.

Python , 40 bytes

f=lambda h,*t:t and h+f(*t)[h>t[0]:]or h

Experimente online!

Insira como tupla de caracteres.

Python 3 , 41 bytes

p=''
for x in input():x<p or print(x);p=x

Experimente online!

Entrada de string.

Python 2 , 41 bytes

for x in input():
 if x>=id:print x
 id=x

Experimente online!

Entrada de string, apenas porque as strings são maiores que, idmas os números são menores.

Wolfram Language (Mathematica) , 33 bytes

Pick[#,Arg[#-{0}~Join~Most@#],0]&

Experimente online!

Como funciona

O código # - {0}~Join~Most@#transforma uma matriz {a,b,c,d,e,f}em {a,b-a,c-b,d-c,e-d,f-e}. A aplicação Arga isso define números negativos para Pie números não negativos para0 .

Pick[#, ..., 0]&seleciona as entradas de #onde ...tem um 0: no nosso caso, exatamente os elementos que produzem um número não negativo quando você subtrai o elemento anterior. Em outras palavras, essas são exatamente as entradas que queremos manter ao preguiçoso.

Maravilha , 27 bytes

-> ':1.!> 'sS#<=.cns2.++[0]

Exemplo de uso:

(-> ':1.!> 'sS#<=.cns2.++[0])[8 6 9 9 7 2 3 8 1 3]

Explicação

Versão não destruída:

(map get 1).(fltr sS <=).(cns 2).(++ [0])

Anexe previamente 0, obtenha a lista de pares consecutivos, mantenha os itens da lista em que o primeiro número <= segundo número, obtenha o segundo número de cada par.

Wolfram Language (Mathematica) , 20 bytes

#&@@@Split[#,##>0&]&
(* or *)
Max/@Split[#,##>0&]&

Experimente online!

Explicação

Input = {8, 6, 9, 9, 7, 2, 3, 8, 1, 3}

Split[#,##>0&]

Agrupe elementos consecutivos que estão estritamente diminuindo: {{8, 6}, {9}, {9, 7, 2}, {3}, {8, 1}, {3}}

#&@@@

Tome o primeiro elemento de cada um: {8, 9, 9, 3, 8, 3}

Python 2 , 52 46 45 42 bytes

lambda a:[v for v,w in zip(a,[1]+a)if v/w]

Experimente online!

Salvou:

• -3 bytes, graças a Rod

SWI-Prolog, 44 bytes

[A,B|C]-[A|E]:-B<A,[B|C]-[B|E];[B|C]-E. L-L.

Uso: Chame " Lista -X" onde Lista é uma lista entre colchetes e separada por vírgula, por exemplo [1,4,5,1,11,6,7].

APL + WIN, 14 bytes

Solicita a entrada na tela de um vetor de números inteiros.

(1,1>2-/v)/v←⎕

05AB1E , 6 bytes

ĆÁü›_Ï

Experimente online!

Explicação

Ć        # append the head of the list
 Á       # rotate right
  ü›     # apply pair-wise greater-than
    _    # logical negate each
     Ï   # keep elements of input that are true in this list

Kotlin , 39 bytes

a->a.filterIndexed{i,v->i<1||v>=a[i-1]}

Experimente online!

Filtre os itens que são o primeiro item (índice == 0 ou ainda menor índice <1) OU o Valor atual é maior ou igual ao item anterior (a [i-1]).

APL (Dyalog Unicode) , 11 bytes

{⍵⌿⍨1⍪2≤⌿⍵}

Experimente online!

Na verdade, isso é bastante semelhante à resposta de Graham, mas em Dyalog, e desenvolvida de forma independente. Além disso, mais simétrico.

K4 , 10 bytes

Solução:

x_/|&<':x:

Exemplo:

q)k)x_/|&<':x:8 6 9 9 7 2 3 8 1 3
8 9 9 3 8 3

Explicação:

Encontre índices onde o elemento é menor que o anterior, remova esses índices da entrada

x_/|&<':x: / the solution
        x: / store input as x
     <':   / less-than each-previous
    &      / indices where true
   |       / reverse
 _/        / drop-over
x          / the input

Anexo , 24 bytes

{Mask[1'(Delta!_>=0),_]}

Experimente online!

Explicação

Maskseleciona todos os elementos de seu segundo argumento que correspondem aos elementos de verdade em seu primeiro argumento. 1'(Delta!_>=0)calcula os índices que correspondem aos elementos que deveriam estar na matriz final.

Outras tentativas

28 bytes (sem ponto): ~Mask#(1&`'##Delta#`>=#C[0])

32 bytes: {Mask[1'(&`<= =>Slices[_,2]),_]}

C # (.NET Core) , 33 + 18 = 51 bytes

x=>x.Where((a,n)=>n<1||x[n-1]<=a)

Experimente online!

basicamente, a instrução é onde x é o primeiro int na matriz ou é maior ou igual ao número anterior, mantenha-o. Caso contrário, solte-o.

Swift 4 , 56 55 bytes

{var l=0;print($0.filter{($0>=l,l=$0).0})}as([Int])->()

Experimente online!

Explicação

{var l=0;           // Declare variable l
print($0.filter{(   // Print every element e in the input
  $0>=l,            //   where e >= l
  l=$0).0})         //   And set l to e
}as([Int])->()      // Set the input type to integer array

Geléia , 9 bytes

0;>ƝżµḢÐṂ

Experimente online!

Isso parece bastante volumoso, não seria tão surpreendente se houver uma maneira melhor.

0;>ƝżµḢÐṂ
   Ɲ       For each adjacent pair in the input...
  >        ...is the first element greater than the second? (yields a list of 0/1)
0;         prepend a zero to this list (always keep the first element)
    ż      zip with the input
     µ     new monadic link
       ÐṂ  keep elements of the list with minimal value of... (Ðḟ would have worked here and been slightly more clear but I'll leave it as it is)
      Ḣ    ...their first element

Flak cerebral , 136 , 120 bytes

((())){{}([{}]({}))([({}<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}{{}(({})<>)(())(<>)}{}([][()])}{}{}<>{{}({}<>)<>}<>

Aqui está formatado e "legível" .

((()))
{
    {}

    ([{}]({}))

    ([({}<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}

    {
        {}(({})<>)(())(<>)
    }

    {}

    ([][()])

}{}{}<>

{
    {}
    ({}<>)<>
}<>

Experimente online!