Ce défi décrit déjà le dropsort. Cependant, je suis un peu paresseux et j'ai vraiment besoin que mon tableau soit un peu plus trié qu'auparavant, il n'a pas besoin d'être trié complètement .

Dans Drop Sort, nous supprimons chaque élément de moins que tout élément précédent. Dans Lazy Drop Sort, nous supprimons chaque élément de moins que celui qui le précède strictement .

Voici un exemple. Considérez le tableau suivant:

8 6 9 9 7 2 3 8 1 3

Marquons chaque élément de moins que celui qui le précède.

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

Remarquez comment ni l'un ni l'autre n'a 3été marqué, ni le dernier 8. Ils sont tous plus grands que l'élément unique à gauche d'eux.

En complétant l'algorithme, en supprimant les éléments marqués, on obtient:

8 9 9 3 8 3

Cela semble fondamentalement plus trié. Un peu. Je suis fainéant.

Votre tâche, comme vous l'avez peut-être déjà déduit, est d'implémenter cet algorithme.

L'entrée est un tableau d'au moins 1 entier positif compris entre 1 et 9, vous pouvez donc également prendre une chaîne de chiffres.

C'est du code-golf , le moins d'octets gagne!

Cas de test supplémentaires:

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

Husk , 4 octets

m←ġ<

Essayez-le en ligne!

Explication

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

JavaScript (ES6), 28 25 octets

Enregistré 3 octets grâce à @Shaggy

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

Essayez-le en ligne!

R , 27 octets

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

Essayez-le en ligne!

MATL , 9 8 octets

Un octet enregistré grâce à Giuseppe.

0yd0<h~)

Essayez-le en ligne!

Explication:

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 octets

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

Essayez-le en ligne!

Haskell, 29 octets

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

juste une simple compréhension de liste.

Japt , 8 7 octets

1 octet enregistré grâce à @Oliver

k@>(U=X

Testez-le en ligne!

Alternatives:

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

Stax , 5 octets

âÿ╠╦░

Exécutez et déboguez ceci en ligne

Déballer, dé-golfer et commenter le code, nous obtenons ceci.

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

Exécutez celui-ci

L'ordre des instructions est maladroit, mais il y a une raison à cela. L'emballage du code source Stax ne donne pas toujours la même sortie de taille pour la même entrée de taille. Fondamentalement, vous avez la possibilité d'enregistrer un octet si le dernier caractère de la source a un code de caractère inférieur. Eh bien, !a l'un des codes les plus bas que vous pouvez obtenir pour un caractère imprimable. (33 spécifiquement) De nombreux programmes stax ASCII de 6 octets ne peuvent pas être plus petits. Mais s'ils se terminent par un !, alors ils le peuvent. Donc, la raison de cet ordre particulier des instructions est de s'assurer que le non logique se termine à la fin du programme.

J, 12 octets

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

Explication:

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

Exemples:

    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

Essayez-le en ligne!

Gelée , 6 octets

>Ɲ0;¬×

Les E / S sont sur des chaînes.

Essayez-le en ligne!

Java 8, 66 55 48 octets

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

-11 octets après un pourboire de @ OlivierGrégoire .
-7 octets de plus grâce à @ OlivierGrégoire .

Explication:

Essayez-le en ligne.

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

Octave , 21 octets

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

Essayez-le en ligne!

Explication:

Prendre un vecteur xen entrée et créer un vecteur[0, diff(x)<0] , oùdiff(x) est un vecteur avec la différence entre tous les éléments adjacents. Ne gardez que ceux qui sont négatifs en le comparant à zéro, en nous donnant une liste de tous les éléments que nous voulons supprimer.

Nous sélectionnons ensuite les éléments du vecteur d'entrée que nous voulons conserver.

V , 25 octets

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

Essayez-le en ligne!

Hexdump:

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

Pire langue pour le travail. Mais je l'ai fait pour oser .

Triangularité , 71 octets

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

Essayez-le en ligne!

Comment ça marche?

) IEL) rFD) 2+) IE) w + h) 2_stDO = {M) IEm} - Programme complet.
) IE - Obtenez la 0e entrée I et évaluez-la.
   L) r - Et poussez la plage [0 ... longueur de I).
      F {- Filtre les entiers de cette gamme qui satisfont:
       D) 2+) IE) w + h) 2_stDO = - Cette condition. Exécute chaque élément E sur un autre
                                    empiler et jeter ceux qui ne répondent pas aux critères.
       D) 2+ - Dupliquez et ajoutez 2 à la deuxième copie.
           ) IE - Récupérez à nouveau I.
              ) - Poussez un 0 sur la pile.
               w - Envelopper le 0 dans une liste. [0]
                + - Ajoutez-le à I.
                 h - Tête. Coupez les éléments après l'index E + 2.
                  ) 2_ - Littéral -2.
                     st - Queue.
                       DO = - Vérifiez si le résultat est invariant par rapport au tri.
                           M) IEm} - Dernière partie: indexation dans l'entrée.
                           M} - Pour chaque indice qui remplit les conditions:
                            ) IEm - Récupère l'élément de I à cette position.

Python , 40 octets

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

Essayez-le en ligne!

Entrez comme tuple de caractères.

Python 3 , 41 octets

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

Essayez-le en ligne!

Entrée chaîne.

Python 2 , 41 octets

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

Essayez-le en ligne!

Entrée de chaîne, juste parce que les chaînes sont plus grandes que idmais les nombres sont plus petits.

Wolfram Language (Mathematica) , 33 octets

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

Essayez-le en ligne!

Comment ça marche

Le code # - {0}~Join~Most@#transforme un tableau {a,b,c,d,e,f}en {a,b-a,c-b,d-c,e-d,f-e}. L'application Argà ceci définit les nombres négatifs sur Piet les nombres non négatifs sur 0.

Pick[#, ..., 0]&sélectionne les entrées de #où ...a a 0: dans notre cas, exactement les éléments qui donnent un nombre non négatif lorsque vous soustrayez l'élément précédent. En d'autres termes, ce sont exactement les entrées que nous voulons conserver lors du lazydropsorting.

Wonder , 27 octets

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

Exemple d'utilisation:

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

Explication

Version non golfée:

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

Ajouter au début 0, obtenir la liste des paires consécutives, conserver les éléments de la liste où le premier numéro <= deuxième numéro, obtenir le deuxième numéro de chaque paire.

Wolfram Language (Mathematica) , 20 octets

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

Essayez-le en ligne!

Explication

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

Split[#,##>0&]

Regroupez les éléments consécutifs qui sont strictement décroissant: {{8, 6}, {9}, {9, 7, 2}, {3}, {8, 1}, {3}}

#&@@@

Prenez le premier élément de chacun: {8, 9, 9, 3, 8, 3}

Python 2 , 52 46 45 42 octets

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

Essayez-le en ligne!

Enregistré:

• -3 octets, grâce à Rod

SWI-Prolog, 44 octets

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

Utilisation: Appelez " List -X" où List est une liste entre crochets, séparée par des virgules, par exemple [1,4,5,1,11,6,7].

APL + WIN, 14 octets

Invite à saisir à l'écran un vecteur d'entiers.

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

05AB1E , 6 octets

ĆÁü›_Ï

Essayez-le en ligne!

Explication

Ć        # 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 octets

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

Essayez-le en ligne!

Filtrer les éléments qui sont soit le premier élément (index == 0, ou encore indice plus court <1) OU la valeur actuelle est supérieure ou égale à l'élément précédent (a [i-1]).

APL (Dyalog Unicode) , 11 octets

{⍵⌿⍨1⍪2≤⌿⍵}

Essayez-le en ligne!

C'est en fait assez similaire à la réponse de Graham, mais dans Dyalog, et développé indépendamment. En outre, plus symétrique.

K4 , 10 octets

Solution:

x_/|&<':x:

Exemple:

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

Explication:

Trouver les indices où l'élément est inférieur au précédent, supprimer ces indices de l'entrée

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

Attaché , 24 octets

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

Essayez-le en ligne!

Explication

Masksélectionne tous les éléments de son deuxième argument qui correspondent aux éléments véridiques de son premier argument. 1'(Delta!_>=0)calcule les indices qui correspondent aux éléments censés se trouver dans le tableau final.

D'autres tentatives

28 octets (sans point): ~Mask#(1&`'##Delta#`>=#C[0])

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

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

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

Essayez-le en ligne!

fondamentalement, l'instruction est l'endroit où x est le premier entier du tableau, ou est supérieur ou égal au nombre précédent, conservez-le. Sinon, laissez tomber.

Swift 4 , 56 55 octets

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

Essayez-le en ligne!

Explication

{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ée , 9 octets

0;>ƝżµḢÐṂ

Essayez-le en ligne!

Cela semble assez volumineux, ne serait pas si surpris s'il y a une meilleure façon.

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 octets

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

Ici, il est formaté et "lisible" .

((()))
{
    {}

    ([{}]({}))

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

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

    {}

    ([][()])

}{}{}<>

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

Essayez-le en ligne!