Sortiere ein Array

44

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 31 .

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 , also gewinnt der kürzeste Code in Bytes.

ETHproductions
quelle
4
Was ist der Clou dieser Sortiermethode?
mbomb007
1
@ mbomb007 Ich verstehe die Big-O-Notation nicht sehr gut, aber ich denke, eine einzelne Iteration ist O (n). Multiplizieren Sie das mit Worst-Case-n-Iterationen und Sie erhalten O (n ^ 2) (Worst-Case; der beste Fall wäre O (n), denke ich, für eine einzelne Iteration).
ETHproductions
1
Das hört sich für mich richtig an, aber es lohnt sich darauf hinzuweisen, dass das Umkehren eines Arrays keine sehr effiziente Operation ist, daher ist es langsamO(n^2)
DJMcMayhem
2
@WheatWizard zum Umkehren eines Arrays benötigt keinen Platz für eine Kopie des Arrays, nur Platz für ein einzelnes Element. und ist O(n). Tauschen Sie das erste und das letzte Element aus. Tauschen Sie dann das vorletzte und das vorletzte Element usw. aus, wenn Sie den mittleren Anschlag erreicht haben.
Jasen
Das O(n)Umkehren ist , aber das Umkehren kann direkt in den Algorithmus eingebaut werden (das ist, was meine JS-Antwort tut). Da jede Iteration jedes Element im Array einmal durchläuft, handelt es sich um eine einzelne Iteration O(n). (Ich denke ...)
ETHproductions

Antworten:

19

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

ETHproductions
quelle
Können Sie erklären , wie Sie Ihr Array in Ihrem ersten Parameter analysiert wird [n,...a]. Was ist n? Ist das nur das erste Element in Ihrem Array?
Oliver
1
@obarakon Richtig. nist das erste Element im Array und ader Rest des Arrays. Weitere Infos finden Sie hier .
ETHproductions
Danke. Das war sehr hilfreich. Warum müssen Sie das einschließen, da Ihr erster Parameter ein Array ist ...a? Ist das nur so, dass Sie davon profitieren können n? Eine weitere Sache, wenn Sie anrufen f(a,q), wird qauf den Parameter gesetzt z?
Oliver
1
@obarakon Nun, f=([n])=>...würde nur das erste Element f=([n,a])=>...erfassen und würde nur das erste in nund das zweite in erfassen a. Ein anderer Weg, was zu tun f=([n,...a])=>,,,wäre f=a=>(n=a.unshift(),....
ETHproductions
1
Und da zist der zweite Parameter in der Funktion, wenn f(a,q)aufgerufen wird, fsieht es als z. Hoffe das hilft!
ETHproductions
11

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.
Lynn
quelle
1
Ich war kurz davor, Save Edits zu treffen, als ich deine Antwort sah ... Gut gemacht.
Dennis
@Dennis Heh, du hast also Dyalog partitioniert beigelegt, aber was ist mit der APL2-Partition?
Adám
11

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

Arnauld
quelle
2
Keine Sorge, ich mag es, verschiedene Ansätze zu sehen. Und oft wird man nach dem Golfen kürzer als der andere :-)
ETHproductions
8

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]
Luis Mendo
quelle
Ich habe deine Antwort auf Octave übersetzt und 31 Bytes gespart!
Rahnema1
7

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.

LegionMammal978
quelle
Schlagen Sie mich dazu! :)
Greg Martin
5

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.

FlipTack
quelle
Ich denke die erste Zeile kann sein d,L,x=input(),[],0;d+=....
Daniel
@ Dopapp, das ist genau die gleiche Anzahl von Bytes
FlipTack
4

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(^)
Blau
quelle
4

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
mbomb007
quelle
4

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£í˜
Emigna
quelle
Diese Zeilenumbrüche haben es wunderbar erklärt ... :-P
Stewie Griffin
@StewieGriffin: Ja, ich habe den Code geändert und gepostet, bevor ich die Erklärung umgeschrieben habe: P
Emigna
4

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.

XavCo7
quelle
Nett! Ich denke, Sie können tun return(b+","+c).split`,` , um ein paar Bytes am Ende zu sparen.
ETHproductions
1
Besser noch, Sie können verwenden, c.unshiftanstatt c.pushdie Notwendigkeit zu entfernen, umzukehren c. Danach habe ich 94 Bytes .
ETHproductions
3

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]
manonthemat
quelle
1
Willkommen, schöne <s> erste </ s> zweite Antwort, überprüfen Sie dies: codegolf.stackexchange.com/questions/363/…
GB
Danke vielmals. Verwandelte dies in ein Lambda, wie in dem von Ihnen bereitgestellten Link vorgeschlagen, und sparte auf diese Weise 5 Bytes.
Manonthemat
2

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
Tödlich
quelle
cVersuchen Brachylogs , wenn sie in umgekehrter Reihenfolge ausgeführt werden, zuerst, sie in weniger Listen aufzuteilen?
@ ais523 ja, das tut es.
Fatalize
1

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 .

Adam
quelle
1

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.

nimi
quelle
1

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!

Martin Ender
quelle
1

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
Billywob
quelle
60 Bytes verwenden diffinvanstatt cumsum.
Giuseppe
1

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{:}]
rahnema1
quelle
0

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).

smls
quelle
0

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)
Conor O'Brien
quelle
0

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]
Noodle9
quelle
Anstatt append zu verwenden, wird += data,implizit ein Tupel erstellt, das dann mit der Liste verkettet wird, wobei die Daten als letztes Element in der Liste hinzugefügt werden. In diesem Zusammenhang machen Sier+=l[i:j+1][::-1],
FlipTack
0

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

Sergei Patiakin
quelle
0

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.

sonrad10
quelle
0

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.

NikoNyrh
quelle