Diese Herausforderung beschreibt bereits Dropsort. Allerdings bin ich ein bisschen faul und ich brauche wirklich nur ein bisschen mehr Sortierung für mein Array als zuvor, es muss nicht vollständig sortiert werden .

In Drop Sort löschen wir jedes Element weniger als jedes Element davor. In Lazy Drop Sort löschen wir jedes Element, das kleiner ist als dasjenige, das genau davor steht.

Hier ist ein Beispiel. Betrachten Sie das folgende Array:

8 6 9 9 7 2 3 8 1 3

Markieren wir jedes Element kleiner als das vorhergehende.

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

Beachten Sie, wie weder 3markiert wurde, noch die letzte 8. Sie sind alle größer als das einzelne Element links von ihnen.

Wenn Sie den Algorithmus vervollständigen und die markierten Elemente entfernen, erhalten Sie:

8 9 9 3 8 3

Das sieht im Grunde mehr sortiert aus. Irgendwie. Ich bin faul.

Wie Sie vielleicht bereits herausgefunden haben, besteht Ihre Aufgabe darin, diesen Algorithmus zu implementieren.

Die Eingabe ist ein Array mit mindestens 1 positiven Ganzzahl zwischen 1 und 9, sodass Sie auch eine Ziffernfolge verwenden können.

Das ist Code-Golf , die wenigsten Bytes gewinnen!

Zusätzliche Testfälle:

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

Schale , 4 Bytes

m←ġ<

Probieren Sie es online!

Erläuterung

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

JavaScript (ES6), 28 bis 25 Byte

3 Bytes gespart dank @Shaggy

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

Probieren Sie es online!

R , 27 Bytes

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

Probieren Sie es online!

MATL , 9 8 Bytes

Dank Giuseppe ein Byte gespart.

0yd0<h~)

Probieren Sie es online!

Erläuterung:

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

Probieren Sie es online!

Haskell, 29 Bytes

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

nur ein einfaches Listenverständnis.

Japt , 8 7 Bytes

1 Byte dank @Oliver gespeichert

k@>(U=X

Online testen!

Alternativen:

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

Stax , 5 Bytes

âÿ╠╦░

Führen Sie dies online aus und debuggen Sie es

Wir packen den Code aus, entgolfen ihn und kommentieren ihn.

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

Führen Sie dieses aus

Die Reihenfolge der Anweisungen ist umständlich, aber es gibt einen Grund dafür. Das Packen von Stax-Quellcode liefert nicht immer die gleiche Ausgabegröße für die gleiche Eingabegröße. Grundsätzlich haben Sie die Möglichkeit, ein Byte zu speichern, wenn das letzte Zeichen der Quelle einen niedrigeren Zeichencode hat. Hat !einen der niedrigsten Codes, die Sie für ein druckbares Zeichen bekommen können. (Speziell 33) Viele 6-Byte-ASCII-Stax-Programme können nicht kleiner packen. Aber wenn sie mit einem enden !, dann können sie es. Der Grund für diese spezielle Reihenfolge von Anweisungen ist es, sicherzustellen, dass die Logik nicht am Ende des Programms endet.

J, 12 Bytes

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

Erläuterung:

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

Beispiele:

    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

Probieren Sie es online!

Gelee , 6 Bytes

>Ɲ0;¬×

I / O ist auf Saiten.

Probieren Sie es online!

Java 8, 66 55 48 Bytes

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

-11 Bytes nach einem Tipp von @ OlivierGrégoire .
-7 weitere Bytes dank @ OlivierGrégoire .

Erläuterung:

Probieren Sie es online aus.

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

Oktave , 21 Bytes

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

Probieren Sie es online!

Erläuterung:

Nehmen Sie einen Vektor xals Eingabe und erstellen Sie einen Vektor [0, diff(x)<0]. Dabei diff(x)handelt es sich um einen Vektor mit dem Unterschied zwischen allen benachbarten Elementen. Behalten Sie nur diejenigen bei, die negativ sind, indem Sie sie mit Null vergleichen, und geben Sie uns eine Liste aller Elemente, die wir löschen möchten.

Wir wählen dann die Elemente aus dem Eingabevektor aus, die wir behalten möchten.

V , 25 Bytes

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

Probieren Sie es online!

Hexdump:

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

Schlechteste Sprache für den Job. Aber ich habe es für eine Herausforderung getan .

Dreieckigkeit , 71 Bytes

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

Probieren Sie es online!

Wie es funktioniert?

) IEL) rFD) 2+) IE) w + h) 2_stDO = {M) IEm} - Volles Programm.
) IE - Hole den 0. Eingang I und bewerte ihn.
   L) r - Drücken Sie den Bereich [0 ... Länge von I).
      F {- Filter die ganzen Zahlen in diesem Bereich, die erfüllen:
       D) 2+) IE) w + h) 2_stDO = - Diese Bedingung. Führt jedes Element E auf einem eigenen aus
                                    Stapeln und verwerfen Sie diejenigen, die die Kriterien nicht erfüllen.
       D) 2+ - Duplizieren Sie und fügen Sie 2 zur zweiten Kopie hinzu.
           ) IE - Ich wiederhole.
              ) - Schieben Sie eine 0 auf den Stapel.
               w - Wickle die 0 in eine Liste. [0]
                + - Stelle es I voran.
                 h - Kopf. Trimmen Sie die Elemente nach dem Index E + 2.
                  ) 2_ - Literal -2.
                     st - Schwanz.
                       DO = - Überprüfen Sie, ob das Ergebnis über die Sortierung unveränderlich ist.
                           M) IEm} - Letzter Teil: Indizieren in die Eingabe.
                           M} - Für jeden Index, der die Bedingungen erfüllt:
                            ) IEm - Ruft das Element von I an dieser Position ab.

Python , 40 Bytes

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

Probieren Sie es online!

Eingabe als Tupel von Zeichen.

Python 3 , 41 Bytes

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

Probieren Sie es online!

Zeichenfolge eingeben.

Python 2 , 41 Bytes

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

Probieren Sie es online!

Zeichenketteneingabe, nur weil Zeichenketten größer als, idaber Zahlen kleiner sind.

Wolfram Language (Mathematica) , 33 Byte

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

Probieren Sie es online!

Wie es funktioniert

Der Code # - {0}~Join~Most@#verwandelt ein Array {a,b,c,d,e,f}in {a,b-a,c-b,d-c,e-d,f-e}. Wenn Sie Argdies anwenden, werden negative Piund nicht negative Zahlen auf gesetzt 0.

Pick[#, ..., 0]&wählt die Einträge aus, in #denen ...ein 0: steht, in unserem Fall genau die Elemente, die eine nichtnegative Zahl ergeben, wenn Sie das vorherige Element subtrahieren. Mit anderen Worten, dies sind genau die Einträge, die wir beim Lazydropsorting beibehalten möchten.

Wunder , 27 Bytes

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

Anwendungsbeispiel:

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

Erläuterung

Ungolfed-Version:

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

Voranstellen 0, Liste aufeinanderfolgender Paare abrufen , Listenelemente mit der ersten Nummer <= zweite Nummer beibehalten , zweite Nummer jedes Paares abrufen .

Wolfram Language (Mathematica) , 20 Byte

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

Probieren Sie es online!

Erläuterung

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

Split[#,##>0&]

Gruppieren Sie aufeinanderfolgende Elemente, die streng dekrementieren: {{8, 6}, {9}, {9, 7, 2}, {3}, {8, 1}, {3}}

#&@@@

Nehmen Sie das erste Element von jedem: {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]

Probieren Sie es online!

Gerettet:

• -3 Bytes, danke an Rod

SWI-Prolog, 44 Bytes

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

Verwendung: Rufen Sie " List -X" auf, wobei List eine in eckige Klammern gesetzte, durch Kommas getrennte Liste ist, z. B. [1,4,5,1,11,6,7].

APL + WIN, 14 Bytes

Fordert zur Eingabe eines Ganzzahlvektors auf.

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

05AB1E , 6 Bytes

ĆÁü›_Ï

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Filtern Sie Elemente, die entweder das erste Element sind (index == 0 oder sogar kürzer index <1), ODER der aktuelle Wert ist größer oder gleich dem vorherigen Element (a [i-1]).

APL (Dyalog Unicode) , 11 Bytes

{⍵⌿⍨1⍪2≤⌿⍵}

Probieren Sie es online!

Dies ist eigentlich ziemlich ähnlich zu Grahams Antwort, aber in Dyalog und unabhängig entwickelt. Auch symmetrischer.

K4 , 10 Bytes

Lösung:

x_/|&<':x:

Beispiel:

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

Erläuterung:

Suchen Sie nach Indizes, bei denen das Element kleiner als das vorherige ist, und entfernen Sie diese Indizes aus der Eingabe

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

Attache , 24 Bytes

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

Probieren Sie es online!

Erläuterung

MaskWählt alle Elemente aus dem zweiten Argument aus, die den wahrheitsgemäßen Elementen im ersten Argument entsprechen. 1'(Delta!_>=0)berechnet die Indizes, die Elementen entsprechen, die im endgültigen Array enthalten sein sollen.

Andere Versuche

28 Bytes (punktfrei): ~Mask#(1&`'##Delta#`>=#C[0])

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

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

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

Probieren Sie es online!

Im Grunde ist die Anweisung, wo x das erste int im Array ist oder größer oder gleich der vorherigen Zahl ist, behalte es bei. Sonst lass es fallen.

Swift 4 , 56, 55 Bytes

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

Probieren Sie es online!

Erläuterung

{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

Gelee , 9 Bytes

0;>ƝżµḢÐṂ

Probieren Sie es online!

Das fühlt sich ziemlich sperrig an, wäre nicht so überrascht, wenn es einen besseren Weg gibt.

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

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

Hier ist es formatiert und "lesbar" .

((()))
{
    {}

    ([{}]({}))

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

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

    {}

    ([][()])

}{}{}<>

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

Probieren Sie es online!