Herausforderung

Bei einem nicht leeren Array von ganzen Zahlen, zB:

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

Teilen Sie es zunächst in Arrays auf, in denen kein Element größer als das vorherige ist (dh nicht aufsteigende Arrays):

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

Kehren Sie als Nächstes jedes Array um:

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

Zum Schluss verketten Sie sie alle miteinander:

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

Dies sollte sein, was Ihre Programmausgaben / -funktion zurückgibt. Wiederholen Sie diesen Vorgang so oft, bis das Array vollständig sortiert ist.

Regeln

• Die Ein- und Ausgabe kann durch beliebige Standardmethoden erfolgen und in einem beliebigen vernünftigen Array-Format erfolgen.
• Das Eingabearray ist niemals leer, kann jedoch Negative und / oder Duplikate enthalten.
• Der absolute Wert jeder Ganzzahl ist immer kleiner als 2 ³¹ .

Testfälle

Hoffentlich decken diese alle Randfälle ab:

[1] -> [1]
[1, 1] -> [1, 1]
[1, 2] -> [1, 2]
[2, 1] -> [1, 2]
[2, 3, 1] -> [2, 1, 3]
[2, 1, 3] -> [1, 2, 3]
[2, 1, 2] -> [1, 2, 2]
[2, 1, 1] -> [1, 1, 2]
[3, 1, 1, 2] -> [1, 1, 3, 2]
[3, 2, 1, 2] -> [1, 2, 3, 2]
[3, 1, 2, 2] -> [1, 3, 2, 2]
[1, 3, 2, 2] -> [1, 2, 2, 3]
[1, 0, 5, -234] -> [0, 1, -234, 5]
[1, 0, 1, 0, 1] -> [0, 1, 0, 1, 1]
[1, 2, 3, 4, 5] -> [1, 2, 3, 4, 5]
[5, 4, 3, 2, 1] -> [1, 2, 3, 4, 5]
[2, 1, 5, 4, 3] -> [1, 2, 3, 4, 5]
[2, 3, 1, 5, 4] -> [2, 1, 3, 4, 5]
[5, 1, 4, 2, 3] -> [1, 5, 2, 4, 3]
[5, 2, 7, 6, 4, 1, 3] -> [2, 5, 1, 4, 6, 7, 3]
[-5, -2, -7, -6, -4, -1, -3] -> [-5, -7, -2, -6, -4, -3, -1]
[14, 5, 3, 8, 15, 7, 4, 19, 12, 0, 2, 18, 6, 11, 13, 1, 17, 16, 10, 9] -> [3, 5, 14, 8, 4, 7, 15, 0, 12, 19, 2, 6, 18, 11, 1, 13, 9, 10, 16, 17]

Wertung

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes.

JavaScript (ES6), 64 Byte

f=([n,...a],z=[],q=[n,...z])=>a+a?n<a[0]?[...q,...f(a)]:f(a,q):q

Rekursion FTW! Der hier verwendete grundlegende Algorithmus besteht darin, den aktuellen nicht aufsteigenden Lauf in einem Array zu verfolgen und ihn "zurückzugeben", wenn ein aufsteigendes Element gefunden wird. Wir tun dies rekursiv und verketten die Ergebnisse fortlaufend, bis wir keine Objekte mehr haben. Durch die Erstellung jedes Laufs in umgekehrter Reihenfolge ( [n,...z]anstelle von [...z,n]) können wir das Langwierige kostenlos vermeiden .reverse().

Testschnipsel

f=([n,...a],z=[],q=[n,...z])=>a+a?n<a[0]?[...q,...f(a)]:f(a,q):q

g=a=>console.log("Input:",`[${a}]`,"Output:",`[${f(a)}]`)

g([1])
g([1,1])
g([1,2])
g([2,1])
g([3,2,1])
g([3,1,2])
g([3,1,1,2])
g([5,2,7,6,4,1,3])

<input id=I value="5, 2, 7, 6, 4, 1, 3">
<button onclick="g((I.value.match(/\d+/g)||[]).map(Number))">Run</button>

Python 3 , 63 Bytes

f=lambda x,*p:x[:1]>p>()and p+f(x)or x and f(x[1:],x[0],*p)or p

Probieren Sie es online!

Gelee , 8 Bytes

Ṁ;<œṗ³UF

Probieren Sie es online!

Erläuterung:

Ṁ;         Prepend the list [a1, a2… an] with its maximum.
  <        Elementwise compare this with the original list:
           [max(a) < a1, a1 < a2, …, a(n-1) < an, an]
           The first element is always 0.
   œṗ³     Partition the original list (³) at the indices
           of the non-zero values in the working list.
           (The spurious `an` at the end of the left argument,
           resulting from comparing lists of different sizes,
           is ignored by this operation, thankfully.)
      U    Reverse each part.
       F   Flatten.

JavaScript (ES6), 70 Byte

Sicher, dies wird bereits von ETHproductions Antwort übertroffen , aber das ist das Beste, was ich bisher ohne Verwendung von Rekursion finden konnte.

a=>a.map((n,i)=>a[x=[...o,...r=[n,...r]],i+1]>n&&(o=x,r=[]),r=o=[])&&x

Hinweis: Das Initialisieren von beiden rund ovon genau demselben Objekt mit r = o = []kann wie eine gefährliche Idee aussehen. Dies ist aber hier sicher, da bei der ersten Iteration mit rsofort eine eigene Instanz (die das erste Element von enthält a) zugewiesen wird r = [n, ...r].

Testfälle

let f =

a=>a.map((n,i)=>a[x=[...o,...r=[n,...r]],i+1]>n&&(o=x,r=[]),r=o=[])&&x

console.log(JSON.stringify(f([1])));
console.log(JSON.stringify(f([1, 1])));
console.log(JSON.stringify(f([1, 2])));
console.log(JSON.stringify(f([2, 1])));
console.log(JSON.stringify(f([2, 3, 1])));
console.log(JSON.stringify(f([2, 1, 3])));
console.log(JSON.stringify(f([2, 1, 2])));
console.log(JSON.stringify(f([2, 1, 1])));
console.log(JSON.stringify(f([3, 1, 1, 2])));
console.log(JSON.stringify(f([3, 2, 1, 2])));
console.log(JSON.stringify(f([3, 1, 2, 2])));
console.log(JSON.stringify(f([1, 3, 2, 2])));
console.log(JSON.stringify(f([1, 0, 5, -234])));
console.log(JSON.stringify(f([1, 0, 1, 0, 1])));
console.log(JSON.stringify(f([1, 2, 3, 4, 5])));
console.log(JSON.stringify(f([5, 4, 3, 2, 1])));
console.log(JSON.stringify(f([2, 1, 5, 4, 3])));
console.log(JSON.stringify(f([2, 3, 1, 5, 4])));
console.log(JSON.stringify(f([5, 1, 4, 2, 3])));
console.log(JSON.stringify(f([5, 2, 7, 6, 4, 1, 3])));
console.log(JSON.stringify(f([-5, -2, -7, -6, -4, -1, -3])));
console.log(JSON.stringify(f([14, 5, 3, 8, 15, 7, 4, 19, 12, 0, 2, 18, 6, 11, 13, 1, 17, 16, 10, 9])));

MATL , 15 Bytes

lidO>vYsGhXSOZ)

Die Eingabe ist ein Spaltenvektor mit dem Format [5; 2; 7; 6; 4; 1; 3](Semikolon ist das Zeilentrennzeichen).

Probieren Sie es online!

Nehmen Sie die Eingabe [5; 2; 7; 6; 4; 1; 3]als Beispiel.

Erläuterung

l     % Push 1
      % STACK: 1
i     % Push input
      % STACK: 1, [5; 2; 7; 6; 4; 1; 3]
d     % Consecutive differences
      % STACK: 1, [-3; 5; -1; -2; -3; 2]
O>    % Test if greater than 0, element-wise
      % STACK: 1, [0; 1; 0; 0; 0; 1]
v     % Concatenate vertically
      % STACK: [1; 0; 1; 0; 0; 0; 1]
Ys    % Cumulative sum
      % STACK: [1; 1; 2; 2; 2; 2; 3]
G     % Push input again
      % STACK: [1; 1; 2; 2; 2; 2; 3], [5; 2; 7; 6; 4; 1; 3]
h     % Concatenate horizontally
      % STACK: [1 5; 1 2; 2 7; 2 6; 2 4; 2 1; 3 3]
XS    % Sort rows in lexicographical order
      % STACK: [1 2; 1 5; 2 1; 2 4; 2 6; 2 7; 3 3]
OZ)   % Get last column. Implicitly display
      % STACK: [2; 5; 1; 4; 6; 7; 3]

Mathematica, 30 27 Bytes

^{3 Bytes gespart durch @Martin Ender .}

Join@@Sort/@Split[#,#>#2&]&

Anonyme Funktion. Nimmt eine Liste von Zahlen als Eingabe und gibt eine Liste von Zahlen als Ausgabe zurück.

Python 2, 100 Bytes

Ein wirklich furchtbares Golf, aber ich wollte meine Lösung posten (man übertrifft einfach nicht Dennis) ...

d=input();L=[];x=0;d+=-~d[-1],
for i in range(1,len(d)):
 if d[i]>d[i-1]:L+=d[x:i][::-1];x=i
print L

Test auf repl.it!

Die Eingabe sollte als Python-Listenliteral erfolgen, z [5, 3, 4, 2, 6, 1].

Die Grundidee besteht darin, die Python-Slicing-Syntax umfassend zu nutzen, jeden erforderlichen Abschnitt aus dem Array zu entfernen, ihn umzukehren und dem neuen Array hinzuzufügen.

Pyke, 11 8 Bytes ( alte Version )

$0m<fm_s

Probieren Sie es hier aus! (Funktioniert mit der neuesten Version)

$        -     delta(input)
 0m<     -    map(i<0 for i in ^)
    f    -   split_at(input, ^)
     m_  -  map(reverse, ^)
       s - sum(^)

Netzhaut , 163 Bytes

Ja, ich weiß, wie schrecklich das ist. Unterstützung von Nullen und Negative war Super Spaß. Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

\d+
$*
(?<=-1*)1
x
-

x,1
x¶1
\b(1+),(1+\1)\b
$1¶$2
,,1
,¶1
x,(¶|$)
x¶¶
(?<=\b\1x+(?=,(x+))),\b
¶
O%$#`.(?=(.*))
$.1
+`¶
,
\bx
-x
(\w+)
$.1
^,
0,
,$
,0
,,
,0,
^$
0

Probieren Sie es online aus

Erläuterung:

\d+                         # Convert to unary
$*
(?<=-1*)1                   # Replace negatives with x's instead of 1's
x
-                           # Remove minus sign

x,1                         # Separate if negative before positive
x¶1
\b(1+),(1+\1)\b             # or greater positive follows a positive
$1¶$2
,,1                         # or positive follows a zero
,¶1
x,(¶|$)                     # or zero follows a negative
x¶¶
(?<=\b\1x+(?=,(x+))),\b     # or negative follows a negative of greater magnitude.
¶
O%$#`.(?=(.*))              # Swear at the input, then reverse each line
$.1
+`¶                         # Remove breaks, putting commas back
,
\bx                         # Put the minus signs back
-x
(\w+)                       # Replace unary with length of match (decimal)
$.1
^,                          # Do a bunch of replacements to resurrect lost zeros
0,
,$
,0
,,
,0,
^$
0

05AB1E , 19 18 16 14 Bytes

Mit Luis Mendos Sortiertrick 2 Bytes gespeichert

ü‹X¸ì.pO¹)ø{ø¤

Probieren Sie es online!

Erläuterung

Beispiel Eingabe [5, 2, 7, 6, 4, 1, 3]

ü‹               # pair-wise less-than
                 # STACK: [0, 1, 0, 0, 0, 1]
  X¸ì            # prepend a 1
                 # STACK: [1, 0, 1, 0, 0, 0, 1]
     .p          # prefixes
       O         # sum
                 # STACK: [1, 1, 2, 2, 2, 2, 3]
        ¹        # push input
                 # STACK: [1, 1, 2, 2, 2, 2, 3], [5, 2, 7, 6, 4, 1, 3]
         )       # wrap stack in list
                 # STACK: [[1, 1, 2, 2, 2, 2, 3], [5, 2, 7, 6, 4, 1, 3]]
          ø      # zip
                 # STACK: [[1, 5], [1, 2], [2, 7], [2, 6], [2, 4], [2, 1], [3, 3]]
           {     # sort
                 # STACK: [[1, 2], [1, 5], [2, 1], [2, 4], [2, 6], [2, 7], [3, 3]]
            ø    # zip
                 # STACK: [[1, 1, 2, 2, 2, 2, 3], [2, 5, 1, 4, 6, 7, 3]]
             ¤   # tail
                 # OUTPUT: [2, 5, 1, 4, 6, 7, 3]

Vorherige 16-Byte-Lösung

Dü‹X¸ì.pO.¡€g£í˜

JavaScript (ECMA 6), 121 128 125 119 108 Bytes

f=a=>{p=a[0],c=[],b=[];for(e of a){e>p&&b.push(c.reverse(c=[]));c.push(p=e)}return[].concat.call([],...b,c)}

Der Lambda-Ausdruck verwendet einen einzelnen ArrayParameter a.

Vielen Dank an @ETHproductions, die mir geholfen haben, meinen ersten Fehler zu erkennen.

Rubin, 60 55 Bytes

s=->x{x.slice_when{|p,q|p<q}.map{|z|z.reverse}.flatten} 

Ziemlich genau das, wonach die Herausforderung verlangte. I definiert einen Lambda s, die ein Array nimmt xund Sever (slices) in kleinere Stücke , in denen das folgende Element größer ist als sein würde. Dies gibt einen Enumerator zurück, den wir map aufrufen und die Reihenfolge der Teile umkehren können , bevor wir alles mit flat zusammenführen, wodurch die Elemente in der definierten Reihenfolge zu einem Array verkettet werden .

Tests

p s[[1]]===[1]
p s[[1, 1]]===[1, 1]
p s[[1, 2]]===[1, 2]
p s[[2, 1]]===[1, 2]
p s[[2, 3, 1]]===[2, 1, 3]
p s[[2, 1, 3]]===[1, 2, 3]
p s[[2, 1, 2]]===[1, 2, 2]
p s[[2, 1, 1]]===[1, 1, 2]
p s[[3, 1, 1, 2]]===[1, 1, 3, 2]
p s[[3, 2, 1, 2]]===[1, 2, 3, 2]
p s[[3, 1, 2, 2]]===[1, 3, 2, 2]
p s[[1, 3, 2, 2]]===[1, 2, 2, 3]
p s[[1, 0, 5, -234]]===[0, 1, -234, 5]
p s[[1, 0, 1, 0, 1]]===[0, 1, 0, 1, 1]
p s[[1, 2, 3, 4, 5]]===[1, 2, 3, 4, 5]
p s[[5, 4, 3, 2, 1]]===[1, 2, 3, 4, 5]
p s[[2, 1, 5, 4, 3]]===[1, 2, 3, 4, 5]
p s[[2, 3, 1, 5, 4]]===[2, 1, 3, 4, 5]
p s[[5, 1, 4, 2, 3]]===[1, 5, 2, 4, 3]
p s[[5, 2, 7, 6, 4, 1, 3]]===[2, 5, 1, 4, 6, 7, 3]
p s[[-5, -2, -7, -6, -4, -1, -3]]===[-5, -7, -2, -6, -4, -3, -1]
p s[[14, 5, 3, 8, 15, 7, 4, 19, 12, 0, 2, 18, 6, 11, 13, 1, 17, 16, 10, 9]]===[3, 5, 14, 8, 4, 7, 15, 0, 12, 19, 2, 6, 18, 11, 1, 13, 9, 10, 16, 17]

Brachylog , 10 Bytes

~c:{>=r}ac

Probieren Sie es online!

Erläuterung

~c            Deconcatenate the Input
  :{>=r}a     Each resulting sublist must be non-increasing, and then reverse it
         c    Concatenate

Dyalog APL , 7 15 Bytes

Benötigt ⎕ML←3, was bei vielen Systemen Standard ist. *

{∊⌽¨⍵⊂⍨1+⍵-⌊/⍵}

∊ eintreten (abflachen)

⌽¨ jeweils umgekehrt

⍵⊂⍨ Das Argument wird durch Abschneiden partitioniert, wobei jedes entsprechende Element größer ist als sein Vorgänger in

1+ eins plus

⍵- das Argument minus

⌊/⍵ das kleinste Element des Arguments

Die alte 7-Byte-Lösung schlägt mit nicht positiven ganzen Zahlen fehl:

Benötigt ⎕ML←3, was bei vielen Systemen Standard ist. *

∊⌽¨⊆⍨⎕

∊ eintragen (platt machen)

⌽¨ jeweils umgekehrt

⊂⍨ selbst partitioniert *

* Partition ( ⊂) ist eine Funktion, die das rechte Argument abschneidet, wenn das entsprechende linke Argument größer als das vorhergehende ist. (Leider werden nur nicht negative ganze Zahlen akzeptiert, und Null hat eine besondere Bedeutung.) Ab Version 16 ist diese Funktionalität ⊂auf allen Systemen (auch solchen, auf denen ⎕ML≠3) verfügbar , die das Symbol verwenden ⊆.

Haskell, 49 Bytes

(a:b)%l|any(<a)l=l++b%[a]|1<2=b%(a:l)
_%l=l
(%[])

Anwendungsbeispiel: (%[]) [5,2,7,6,4,1,3]-> [2,5,1,4,6,7,3].

Rekursiver Ansatz. Die Funktion verwendet %die Eingabeliste als ersten Parameter und einen Akkumulator l, der den bisher nicht aufsteigenden Block verfolgt (in umgekehrter Reihenfolge). Der Basisfall ist erreicht, wenn die Eingabeliste leer ist und das Ergebnis der Akkumulator ist. Wenn die Eingabeliste nicht leer ist und das erste Element anicht in den aktuellen Block ( any(<a)l) passt , geben Sie den Akkumulator zurück und fügen Sie einen rekursiven Aufruf an den Rest der Liste und aals neuen Akkumulator ( l++b%[a]) an. Anderenfalls rufen Sie den Rest der Liste rekursiv auf und stellen Sie ihn vor aden Akku ( b%(a:l)). Die Hauptfunktion (%[])ruft %bei leerem Akku auf.

Retina , 98 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

$

-(\d+)
$1$*-/
\d+
$*
S-`(?<=(-+)/ )(?!\1)|(?=\b(1+))(?<!\2 )
O%`\S* 
¶

((-)|1)*/? 
$2$#1 
 $

Probieren Sie es online!

R, 64 Bytes

cat(unlist(lapply(split(x<-scan(),cumsum(c(F,diff(x)>0))),rev)))

Liest die Eingabe von stdin. Wir teilen die Eingabe in eine Liste von Vektoren auf, für split()die eine Faktorvariable erforderlich ist, die die Eingabe gruppiert. Der Faktor ergibt sich aus der kumulativen Summe des logischen Vektors, für den die Differenz positiv ist.

Betrachten Sie den Vektor:

x=c(5, 2, 7, 6, 4, 1, 3)

Wenn Sie nun den Unterschied nehmen und Fdurch Ausführen voranstellen y=c(F,diff(x)>0), wird der folgende logische Vektor erzeugt:

[1] FALSE FALSE  TRUE FALSE FALSE FALSE  TRUE

Die kumulative Summe cumsum(y)ergibt einen Vektor, in dem jede Gruppe durch einen eindeutigen Faktor dargestellt wird, auf den wir mit der splitFunktion kombinieren können:

[1] 0 0 1 1 1 1 2

Oktave, 75 44 Bytes

Basierend auf der MATL-Antwort von @LuisMendo

@(a)sortrows([cumsum([1;diff(a)>0]),a])(:,2)

Probieren Sie es online!

Vorherige Antwort

@(a)[fliplr(mat2cell(f=fliplr(a),1,diff(find([1,diff(f)<0,numel(a)])))){:}]

Probieren Sie es online!

kehren Sie das Array um

f=fliplr(a)

nimm den ersten Unterschied von f

d = diff(f);

Finden Sie die Position, an der das nächste Element kleiner als das vorherige Element ist

p=find([1,diff(f)<0,numel(a)])

Die erste Differenz der Positionen gibt die Länge jedes Unterarrays zurück

len=diff(p)

Verwenden Sie die Länge jedes Unterarrays mat2cell, um das Array in eine verschachtelte Liste von Arrays aufzuteilen

nest = mat2cell(f,1,len);

kehren Sie die verschachtelte Liste um

rev_nest = fliplr(nest) 

Reduzieren Sie die verschachtelte Liste

[rev_nest{:}]

Pyth - 15 Bytes

s_McQf<@QtT@QTU

Probieren Sie es hier online aus .

Perl 6 , 59 Bytes

{map |+«*.[0].reverse,m/:s([(\-?\d+)<?{[>=] $0}>] +)+/[0]}

Regex-basierte Lösung.
Weil das Sparta Perl ist !!

• m/ /: Stringifiziere das Eingabearray und vergleiche einen regulären Ausdruck damit.
• (\-? \d+): Passen Sie eine Zahl an und erfassen Sie sie als $0.
• <?{ [>=] $0 }>: Null-Breiten-Zusicherung, die nur dann zutrifft, wenn alle $0bisher in der aktuellen Teilübereinstimmung erfassten in nicht aufsteigender Reihenfolge sind.
• ([ ] +)+: Wiederholen Sie die letzten beiden Schritte so oft wie möglich, andernfalls starten Sie eine neue Teilübereinstimmung.
• map , [0]: Iteriere über die Submatches.
• |+«*.[0].reverse: Nehmen Sie für jeden Wert die Liste mit den übereinstimmenden Werten $0, kehren Sie sie um, setzen Sie die Werte in Zahlen um ( +«) und fügen Sie sie in die äußere Liste ein ( |).

Perl 6 , 63 Bytes

sub f(\a){flat $_,f a[+$_..*]with first {[<=] $_},:end,[\R,] a}

Lösung für die Verarbeitung rekursiver Listen.
Mühsamer als ich gehofft hatte.
Obwohl die Sprache viele praktische integrierte Funktionen hat, scheint es keine für die Listenpartitionierung zu geben (z. B. Ruby's slice_whenoder Haskell's takeWhile).

Gestapelt , nicht konkurrierend, 34 Bytes

Entwickelt diese Sprache immer weiter.

{e.b:e b last<}chunkby$revmap flat

Das Argument liegt auf TOS. Probieren Sie es hier aus!

chunkbyNimmt eine Funktion und sammelt Arrays zusammenhängender Daten, die die Funktion erfüllen. Die Funktion ist dann:

{e.b:e b last<}
{e.b:         }  function with arguments [e, <unused>, b]--the element, <the index>, and the
                 chunk being built
     e       <   check if e is less than
       b last    the last element of b

Dies ergibt ein streng abnehmendes Array.

$revmapist im Grunde [rev]mapund kehrt jedes Element.

flat Zum Schluss wird das Array abgeflacht.

Ein bisschen Spaß beim Sortieren des Arrays:

[{e.b:e b last<}chunkby$revmap flat] @:sortstep
[$sortstep periodloop] @:sort

10:> @arr
arr out
arr shuf @arr
arr out
arr sort out

Diese Ausgabe (zum Beispiel):

(0 1 2 3 4 5 6 7 8 9)
(4 5 1 0 6 7 2 8 9 3)
(0 1 2 3 4 5 6 7 8 9)

Python, 151 139 Bytes

12 Bytes gespart dank @ Flp.Tkc!

Nirgendwo in der Nähe von @ Flp.Tkc, geschweige denn ...

def s(l):
 r=[];i=j=0
 while j<len(l)-1:
  if l[j+1]>l[j]:r+=l[i:j+1][::-1],;i=j+1
  j+=1
 r+=l[i:j+1][::-1],;return[i for s in r for i in s]

Python 2, 74 Bytes

b=[];c=[];a+=9e9,
for i in a[:-1]:
 b=[a.pop(0)]+b
 if b[0]<a[0]:c+=b;b=[]

Eingabe in a, Ausgabe inc

Python 3, 191 Bytes

a=[int(i)for i in input().split()]
while a!=sorted(a):
 b=[[]]
 for i,j in enumerate(a):
  if a[i-1]<j:b+=[[j]]
  else:b[-1]+=[j]
 a=[]
 for l in[k[::-1]for k in b]:a+=[k for k in l]
print(a)

Ich bin mir nicht sicher, ob die Verwendung der sortedFunktion zum Überprüfen hier zulässig ist, aber ich konnte mir keinen guten Grund dafür vorstellen, und meine Byteanzahl wurde um ~ 30 Bytes gesenkt.

Clojure, 105 Bytes

#(filter number?(mapcat reverse(partition-by not(mapcat(fn[[a b]][a(< b a)])(partition 2 1(conj % 1))))))

Trennwände in Paaren auf fortlaufende Nummern, setzt trueoder falsezwischen ihnen, Partitionen notzu trueund Zahlen werden falseund false truekehrt Partitionen und numerische Werte hält.