Este desafío ya describe dropsort. Sin embargo, soy un poco vago y realmente solo necesito que mi matriz esté un poco más ordenada que antes, no necesita ser ordenada por completo .

En Drop Sort, soltamos cada elemento menos que cualquier elemento anterior. En Lazy Drop Sort, descartamos cada elemento menos que el estrictamente anterior .

Aquí hay un ejemplo. Considere la siguiente matriz:

8 6 9 9 7 2 3 8 1 3

Marquemos cada elemento menos que el anterior.

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

Observe cómo ni 3se marcó, ni el último 8. Todos son más grandes que el elemento individual a la izquierda de ellos.

Completando el algoritmo, eliminando los elementos marcados, obtenemos:

8 9 9 3 8 3

Eso básicamente se ve más ordenado. Un poco Soy perezoso.

Su tarea, como ya habrá deducido, es implementar este algoritmo.

La entrada es una matriz de al menos 1 entero positivo entre 1 y 9, por lo que también puede tomar una cadena de dígitos.

Este es el código de golf , ¡la menor cantidad de bytes gana!

Casos de prueba adicionales:

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

Casco , 4 bytes

m←ġ<

Pruébalo en línea!

Explicación

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

JavaScript (ES6), 28 25 bytes

Guardado 3 bytes gracias a @Shaggy

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

Pruébalo en línea!

R , 27 bytes

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

Pruébalo en línea!

MATL , 9 8 bytes

Guardado un byte gracias a Giuseppe.

0yd0<h~)

Pruébalo en línea!

Explicación:

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=$_

Pruébalo en línea!

Haskell, 29 bytes

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

solo una simple lista de comprensión.

Japt , 8 7 bytes

Guardado 1 byte gracias a @Oliver

k@>(U=X

¡Pruébalo en línea!

Alternativas:

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

Stax , 5 bytes

âÿ╠╦░

Ejecute y depure esto en línea

Desempacando, desempañando y comentando el código, obtenemos esto.

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

Ejecute este

El orden de las instrucciones es incómodo, pero hay una razón para ello. El empaquetado del código fuente Stax no siempre produce el mismo tamaño de salida para el mismo tamaño de entrada. Básicamente, tiene la posibilidad de guardar un byte si el último carácter de origen tiene un código de caracteres más bajo. Bueno, !tiene uno de los códigos más bajos que puede obtener para un personaje imprimible. (33 específicamente) Muchos programas ASCII stax de 6 bytes no pueden empacar más pequeños. Pero si terminan con un !, entonces pueden. Entonces, la razón de este orden particular de instrucciones es asegurar que lo lógico no termine al final del programa.

J, 12 bytes

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

Explicación:

#~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

Ejemplos:

    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

Pruébalo en línea!

Jalea , 6 bytes

>Ɲ0;¬×

I / O está en cadenas.

Pruébalo en línea!

Java 8, 66 55 48 bytes

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

-11 bytes después de un consejo de @ OlivierGrégoire .
-7 bytes más gracias a @ OlivierGrégoire .

Explicación:

Pruébalo en línea.

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

Octava , 21 bytes

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

Pruébalo en línea!

Explicación:

Tome un vector xcomo entrada y cree un vector [0, diff(x)<0], donde diff(x)es un vector con la diferencia entre todos los elementos adyacentes. Mantenga solo aquellos que son negativos al compararlo con cero, dándonos una lista de todos los elementos que queremos eliminar.

Luego seleccionamos los elementos del vector de entrada que queremos mantener.

V , 25 bytes

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

Pruébalo en línea!

Hexdump:

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

El peor idioma para el trabajo. Pero lo hice por un desafío .

Triangularidad , 71 bytes

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

Pruébalo en línea!

¿Cómo funciona?

) IEL) rFD) 2+) IE) w + h) 2_stDO = {M) IEm} - Programa completo.
) IE: obtenga la entrada 0a I y evalúela.
   L) r - Y empuje el rango [0 ... longitud de I).
      F {- Filtra los enteros en este rango que satisfacen:
       D) 2+) IE) w + h) 2_stDO = - Esta condición. Ejecuta cada elemento E en un elemento separado.
                                    apilar y descartar aquellos que no cumplan con los criterios.
       D) 2+: duplicar y agregar 2 a la segunda copia.
           ) IE - Recuperar I de nuevo.
              ) - Empuja un 0 en la pila.
               w: ajusta el 0 en una lista. [0]
                + - Anteponerlo a I.
                 h - Cabeza. Recorte los elementos después del índice E + 2.
                  ) 2_ - Literal -2.
                     st - cola.
                       DO = - Verifique si el resultado es invariable sobre la clasificación.
                           M) IEm} - Última parte: indexación en la entrada.
                           M} - Para cada índice que cumple las condiciones:
                            ) IEm: recupera el elemento de I en esa posición.

Python , 40 bytes

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

Pruébalo en línea!

Entrada como tupla de caracteres.

Python 3 , 41 bytes

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

Pruébalo en línea!

Cadena de entrada.

Python 2 , 41 bytes

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

Pruébalo en línea!

Entrada de cadena, solo porque las cadenas son mayores que idpero los números son más pequeños.

Wolfram Language (Mathematica) , 33 bytes

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

Pruébalo en línea!

Cómo funciona

El código # - {0}~Join~Most@#convierte una matriz {a,b,c,d,e,f}en {a,b-a,c-b,d-c,e-d,f-e}. Al aplicar Argesto, se establecen números negativos Piy números no negativos 0.

Pick[#, ..., 0]&selecciona las entradas de #where ...tiene a 0: en nuestro caso, exactamente los elementos que producen un número no negativo cuando resta el elemento anterior. En otras palabras, estas son exactamente las entradas que queremos mantener cuando lazydropsorting.

Maravilla , 27 bytes

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

Ejemplo de uso:

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

Explicación

Versión sin golf:

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

Anteponer 0, obtener una lista de pares consecutivos, mantener elementos de la lista donde el primer número <= segundo número, obtener el segundo número de cada par.

Wolfram Language (Mathematica) , 20 bytes

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

Pruébalo en línea!

Explicación

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

Split[#,##>0&]

Agrupe elementos consecutivos que disminuyan estrictamente: {{8, 6}, {9}, {9, 7, 2}, {3}, {8, 1}, {3}}

#&@@@

Tome el primer elemento de cada uno: {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]

Pruébalo en línea!

Salvado:

• -3 bytes, gracias a Rod

SWI-Prolog, 44 bytes

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

Uso: Llame a " Lista -X" donde Lista es una lista separada por comas, separada por comas, p. Ej. [1,4,5,1,11,6,7].

APL + WIN, 14 bytes

Solicita la entrada de pantalla de un vector de enteros.

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

05AB1E , 6 bytes

ĆÁü›_Ï

Pruébalo en línea!

Explicación

Ć        # 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]}

Pruébalo en línea!

Filtre los elementos que son el primer elemento (índice == 0, o incluso un índice más corto <1) O el valor actual es mayor o igual que el elemento anterior (a [i-1]).

APL (Dyalog Unicode) , 11 bytes

{⍵⌿⍨1⍪2≤⌿⍵}

Pruébalo en línea!

En realidad, esto es bastante similar a la respuesta de Graham, pero en Dyalog, y desarrollado de forma independiente. Además, más simétrico.

K4 , 10 bytes

Solución:

x_/|&<':x:

Ejemplo:

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

Explicación:

Encuentre índices donde el elemento sea menor que el anterior, elimine estos índices de la entrada

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

Adjunto , 24 bytes

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

Pruébalo en línea!

Explicación

Maskselecciona todos los elementos de su segundo argumento que corresponden a elementos de verdad en su primer argumento. 1'(Delta!_>=0)calcula los índices que corresponden a elementos que se supone que están en la matriz final.

Otros intentos

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

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

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

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

Pruébalo en línea!

básicamente la declaración es donde x es el primer int en la matriz, o es mayor o igual que el número anterior, guárdelo. De lo contrario, déjalo caer.

Swift 4 , 56 55 bytes

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

Pruébalo en línea!

Explicación

{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

Jalea , 9 bytes

0;>ƝżµḢÐṂ

Pruébalo en línea!

Esto se siente bastante voluminoso, no estaría tan sorprendido si hay una mejor manera.

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

Brain-Flak , 136 , 120 bytes

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

Aquí está formateado y "legible" .

((()))
{
    {}

    ([{}]({}))

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

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

    {}

    ([][()])

}{}{}<>

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

Pruébalo en línea!