Sortuj według tablicy

44

Wyzwanie

Biorąc pod uwagę niepustą tablicę liczb całkowitych, np .:

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

Najpierw podziel ją na tablice, w których żaden element nie jest większy niż poprzedni (tj. Tablice nie rosnąco):

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

Następnie odwróć każdą tablicę:

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

Na koniec połącz je wszystkie razem:

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

To powinno być to, co zwraca program / funkcja. Powtórz tę procedurę wystarczająco dużo razy, a tablica zostanie w pełni posortowana.

Zasady

  • Dane wejściowe i wyjściowe mogą być podawane dowolnymi standardowymi metodami i mogą mieć dowolny rozsądny format macierzowy.
  • Tablica wejściowa nigdy nie będzie pusta, ale może zawierać negatywy i / lub duplikaty.
  • Wartość bezwzględna każdej liczby całkowitej będzie zawsze mniejsza niż 2 31 .

Przypadki testowe

Mam nadzieję, że obejmują one wszystkie przypadki krawędzi:

[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]

Punktacja

To jest , więc wygrywa najkrótszy kod w bajtach.

ETHprodukcje
źródło
4
Jaka jest zaleta tej metody sortowania?
mbomb007,
1
@ mbomb007 Nie rozumiem bardzo dobrze notacji big-o, ale myślę, że pojedyncza iteracja to O (n). Pomnóż to przez iteracje najgorszego przypadku, a otrzymasz O (n ^ 2) (najgorszy przypadek; najlepszym przypadkiem byłoby O (n), jak sądzę, dla pojedynczej iteracji).
ETHprodukcje
1
Brzmi to dla mnie dobrze, jednak warto zauważyć, że odwrócenie tablicy nie jest bardzo wydajną operacją, więc jest powolneO(n^2)
DJMcMayhem
2
Odwracanie tablicy @WheatWizard nie wymaga miejsca na kopię tablicy, tylko miejsce na pojedynczy element. i jest O(n). zamień pierwszy i ostatni element, a następnie zamień drugi i drugi ostatni element itp., kiedy dojdziesz do środkowego przystanku.
Jasen
Cofanie jest O(n), ale cofanie może być wbudowane w algorytm (tak robi moja odpowiedź JS); ponieważ każda iteracja zapętla się raz nad każdym elementem w tablicy, pojedyncza iteracja to O(n). (Myślę, że ...)
ETHproductions

Odpowiedzi:

19

JavaScript (ES6), 64 bajty

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

Rekursja FTW! Podstawowym wykorzystywanym tutaj algorytmem jest śledzenie bieżącego nie rosnącego przebiegu w tablicy, „zwracanie” go za każdym razem, gdy zostanie znaleziony element rosnący. Robimy to rekurencyjnie, ciągle łącząc wyniki, dopóki nie zabraknie przedmiotów. Tworząc każdy przebieg w odwrotnej kolejności ( [n,...z]zamiast [...z,n]), możemy uniknąć długiego .reverse()bez żadnych kosztów.

Testowy fragment kodu

ETHprodukcje
źródło
Czy możesz wyjaśnić, w jaki sposób tablica jest analizowana do pierwszego parametru [n,...a]. Co to jest n? Czy to tylko pierwszy element w twojej tablicy?
Oliver,
1
@obarakon Prawidłowo. njest pierwszym elementem w tablicy i ajest resztą tablicy. Więcej informacji znajdziesz tutaj .
ETHproductions
Dziękuję Ci. To było bardzo pomocne. Ponieważ twoim pierwszym parametrem jest tablica, dlaczego musisz dołączyć ...a? Czy to tylko po to, abyś mógł z tego skorzystać n? Jeszcze jedna rzecz, kiedy dzwonisz f(a,q), czy qustawiony jest parametr z?
Oliver
1
@obarakon Cóż, f=([n])=>...przechwyciłby tylko pierwszy element i f=([n,a])=>...przechwyciłby tylko pierwszy ni drugi a. Innym sposobem na zrobienie tego, co f=([n,...a])=>,,,by było f=a=>(n=a.unshift(),....
ETHproductions
1
A ponieważ zjest to drugi parametr w funkcji, gdy f(a,q)jest wywoływany, fwidzi go jako z. Mam nadzieję że to pomoże!
ETHproductions
14

Python 3 , 63 bajty

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

Wypróbuj online!

Dennis
źródło
11

Galaretka , 8 bajtów

Ṁ;<œṗ³UF

Wypróbuj online!

Wyjaśnienie:

Ṁ;         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
źródło
1
Byłem na granicy zapisywania zmian, kiedy zobaczyłem twoją odpowiedź ... Dobra robota.
Dennis
@Dennis Heh, więc dodałeś załączone partycje Dyalog, ale co z partycją APL2?
Adám
11

JavaScript (ES6), 70 bajtów

Jasne, jest to już pokonane przez odpowiedź ETHproductions , ale to najlepsze, co mogłem wymyślić do tej pory bez korzystania z rekurencji.

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

Uwaga: Inicjowanie obu ri odokładnie tego samego obiektu za pomocą r = o = []może wyglądać jak niebezpieczny pomysł. Ale jest to bezpieczne, ponieważ rjest to natychmiast przypisywane do własnej instancji (zawierającej pierwszy element a) przy pierwszej iteracji z r = [n, ...r].

Przypadki testowe

Arnauld
źródło
2
Bez obaw, uwielbiam widzieć różne podejścia. I jeden często staje się krótszy od drugiego po
grze w
8

MATL , 15 bajtów

lidO>vYsGhXSOZ)

Dane wejściowe to wektor kolumny o formacie [5; 2; 7; 6; 4; 1; 3](średnik jest separatorem wierszy).

Wypróbuj online!

Weź [5; 2; 7; 6; 4; 1; 3]przykład jako przykład.

Wyjaśnienie

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
źródło
Przetłumaczyłem twoją odpowiedź na Octave, zaoszczędziłem 31 bajtów!
rahnema1
7

Mathematica, 30 27 bajtów

3 bajty zapisane z powodu @Martin Ender .

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

Funkcja anonimowa. Pobiera listę liczb jako dane wejściowe i zwraca listę liczb jako dane wyjściowe.

LegionMammal978
źródło
Pokonaj mnie do tego! :)
Greg Martin
5

Python 2, 100 bajtów

Naprawdę okropny golf, ale chciałem opublikować moje rozwiązanie (jeden nie jest po prostu lepszy niż 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

Testuj na repl.it!

Dane wejściowe należy podać jako literał listy w języku Python, na przykład [5, 3, 4, 2, 6, 1].

Podstawową ideą jest częste wykorzystanie składni krojenia Pythona, wycinanie każdej potrzebnej sekcji z tablicy, odwracanie jej i dodawanie do nowej tablicy.

FlipTack
źródło
Myślę, że pierwsza linia może być d,L,x=input(),[],0;d+=....
Daniel
@Dopapp, który ma dokładnie taką samą liczbę bajtów
FlipTack
4

Pyke, 11 8 bajtów ( stara wersja )

$0m<fm_s

Wypróbuj tutaj! (działa na najnowszej wersji)

$        -     delta(input)
 0m<     -    map(i<0 for i in ^)
    f    -   split_at(input, ^)
     m_  -  map(reverse, ^)
       s - sum(^)
niebieski
źródło
4

Siatkówka , 163 bajty

Tak, wiem jakie to okropne. Wspieranie zer i negatywy było bardzo zabawne. Liczba bajtów zakłada kodowanie ISO 8859-1.

\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

Wypróbuj online

Wyjaśnienie:

\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
źródło
4

05AB1E , 19 18 16 14 bajtów

Zaoszczędzono 2 bajty, używając sztuczki sortowania Luisa Mendo

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

Wypróbuj online!

Wyjaśnienie

Przykładowe dane wejściowe [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]

Poprzednie 16-bajtowe rozwiązanie

Dü‹X¸ì.pO.¡€g£í˜
Emigna
źródło
Te przełamania linii wspaniale to wyjaśniły ... :-P
Stewie Griffin,
@StewieGriffin: Tak, zmieniłem kod i opublikowałem, zanim przepisałem wyjaśnienie: P
Emigna
4

JavaScript (ECMA 6), 121 128 125 119 108 bajtów

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

Wyrażenie lambda pobiera pojedynczy Arrayparametr a.

Dzięki @ETHproductions za pomoc w zobaczeniu mojego pierwszego błędu.

XavCo7
źródło
Miły! Myślę, że możesz zrobić, return(b+","+c).split`,` aby zaoszczędzić kilka bajtów na końcu.
ETHproductions
1
Jeszcze lepiej, możesz użyć c.unshiftzamiast c.pushusuwać potrzebę cofania c. Po zrobieniu tego mam 94 bajty .
ETHproductions
3

Rubinowy, 60 55 bajtów

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

Prawie o to prosiło wyzwanie. I określonych lambda s, które ma szereg xi Sever (plastry), to na mniejsze kawałki, gdy następny element będzie większy niż. Daje to moduł wyliczający, który możemy nazywać mapą i odwracać kolejność elementów, zanim ostatecznie zbierzemy wszystko razem z spłaszczeniem, które łączy elementy w określonej kolejności w jedną tablicę.

Testy

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
źródło
1
Witaj, miło <s> pierwsza </s> druga odpowiedź, sprawdź to: codegolf.stackexchange.com/questions/363/…
GB
Wielkie dzięki. Zamieniłem to w lambda, jak zasugerowano w podanym linku, i zaoszczędzono w ten sposób 5 bajtów.
manonthemat
2

Brachylog , 10 bajtów

~c:{>=r}ac

Wypróbuj online!

Wyjaśnienie

~c            Deconcatenate the Input
  :{>=r}a     Each resulting sublist must be non-increasing, and then reverse it
         c    Concatenate
Fatalizować
źródło
Czy Brachylog c, gdy działa w odwrotnej kolejności, koniecznie najpierw próbuje podzielić na mniejszą liczbę list?
@ ais523 tak, to robi.
Fatalize
1

Dyalog APL , 7 15 bajtów

Wymaga ⎕ML←3, co jest domyślne w wielu systemach. *

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

zaciągnąć się (spłaszczyć)

⌽¨ każdy odwrócony

⍵⊂⍨ argument podzielony na partycje * poprzez wycięcie, gdzie każdy odpowiadający element jest większy niż jego poprzednik

1+ jeden plus

⍵- argument minus

⌊/⍵ najmniejszy element argumentu


Stare 7-bajtowe rozwiązanie kończy się niepowodzeniem z nieujemnymi liczbami całkowitymi:

Wymaga ⎕ML←3, co jest domyślne w wielu systemach. *

∊⌽¨⊆⍨⎕

zaciągnij (spłaszcz)

⌽¨ każdy odwrócony

⊂⍨ dzielony na części *


* Partition ( ) jest funkcją, która odcina swój prawy argument, gdy odpowiadający mu lewy argument jest większy niż poprzedni. (Niestety akceptuje tylko nieujemne liczby całkowite, a zero ma specjalne znaczenie.) Od wersji 16 ta funkcja jest dostępna we wszystkich systemach (nawet tych, gdzie ⎕ML≠3), za pomocą glifu .

Adám
źródło
1

Haskell, 49 bajtów

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

Przykład użycia: (%[]) [5,2,7,6,4,1,3]-> [2,5,1,4,6,7,3].

Podejście rekurencyjne. Funkcja %przyjmuje listę wejść jako swój pierwszy parametr i akumulator, lktóry śledzi dotychczas nie rosnącą porcję (w odwrotnej kolejności). Przypadek podstawowy jest osiągany, gdy lista wejść jest pusta, a wynikiem jest akumulator. Jeśli lista wejściowa nie jest pusta, a pierwszy element anie mieści się w bieżącej porcji ( any(<a)l), zwróć akumulator i dołącz rekurencyjne wywołanie do reszty listy oraz ajako nowego akumulatora ( l++b%[a]). W przeciwnym razie wykonaj rekurencyjne wywołanie na pozostałej części listy i adołącz do tha accumulator ( b%(a:l)). Główna funkcja (%[])wywołuje %z pustym akumulatorem.

nimi
źródło
1

Siatkówka , 98 bajtów

Liczba bajtów zakłada kodowanie ISO 8859-1.

$

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

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

Wypróbuj online!

Martin Ender
źródło
1

R, 64 bajty

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

Odczytuje dane wejściowe ze standardowego wejścia. Podzieliliśmy dane wejściowe na listę wektorów, split()która wymaga zmiennej czynnikowej grupującej dane wejściowe. Współczynnik jest tworzony przez przyjęcie skumulowanej sumy wektora logicznego, dla którego różnica jest dodatnia.

Rozważ wektor:

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

Teraz wzięcie różnicy i kontynuowanie Fprzez uruchomienie y=c(F,diff(x)>0)wygenerowałoby następujący logiczny wektor:

[1] FALSE FALSE  TRUE FALSE FALSE FALSE  TRUE

Biorąc sumę skumulowaną, cumsum(y)powstaje wektor, w którym każda grupa jest reprezentowana przez unikalny czynnik, na podstawie którego możemy łączyć się z splitfunkcją:

[1] 0 0 1 1 1 1 2
Billywob
źródło
60 bajtów używając diffinvzamiast cumsum.
Giuseppe,
1

Oktawa, 75 44 bajtów

Na podstawie odpowiedzi MATL @LuisMendo

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

Wypróbuj online!

Poprzednia odpowiedź

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

Wypróbuj online!

odwróć tablicę

f=fliplr(a)

weź pierwszą różnicę f

d = diff(f);

znajdź pozycję, w której następny element jest mniejszy niż poprzedni element

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

pierwsza różnica pozycji zwraca długość każdej podtablicy

len=diff(p)

użyj długości każdej podtablicy, mat2cellaby podzielić tablicę na zagnieżdżoną listę tablic

nest = mat2cell(f,1,len);

odwróć listę zagnieżdżoną

rev_nest = fliplr(nest) 

spłaszcz listę zagnieżdżoną

[rev_nest{:}]
rahnema1
źródło
0

Perl 6 , 59 bajtów

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

Rozwiązanie oparte na regeksie.
Ponieważ to jest Sparta Perl !!

  • m/ /: Zmodyfikuj tablicę wejściową i dopasuj do niej wyrażenie regularne.
  • (\-? \d+): Dopasuj liczbę i przechwyć jako $0.
  • <?{ [>=] $0 }>: Asercja o zerowej szerokości, która pasuje tylko wtedy, gdy wszystkie $0wychwycone do tej pory w bieżącym podpasowaniu są w kolejności rosnącej.
  • ([ ] +)+: Powtarzaj dwa ostatnie kroki tak często, jak to możliwe, w przeciwnym razie rozpocznij nowy mecz podrzędny.
  • map , [0]: Powtarzaj pod-mecze.
  • |+«*.[0].reverse: Dla każdego z nich weź listę dopasowanych wartości $0, odwróć ją, wymuś wartości na liczby ( ) i wsuń je na zewnętrzną listę ( |).

Perl 6 , 63 bajtów

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

Rozwiązanie do przetwarzania listy rekurencyjnej.
Bardziej pracochłonny, niż się spodziewałem.
Mimo że język ma wiele wygodnych wbudowanych funkcji, wydaje się, że nie ma żadnego partycjonowania list (np. Ruby slice_whenlub Haskell takeWhile).

smls
źródło
0

Skumulowane , niekonkurencyjne, 34 bajty

Ciągle rozwijam ten język.

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

Argument dotyczy TOS. Wypróbuj tutaj!

chunkbyprzejmuje funkcję i zbiera tablice ciągłych danych, które spełniają tę funkcję. Funkcja to:

{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

Daje to ściśle malejącą tablicę.

$revmapjest w zasadzie [rev]mapi odwraca każdy element.

flat w końcu spłaszcza tablicę.


Trochę zabawy podczas sortowania tablicy:

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

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

Dane wyjściowe (na przykład):

(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
źródło
0

Python, 151 139 bajtów

Zapisano 12 bajtów dzięki @ Flp.Tkc!

Nigdzie w pobliżu @ Flp.Tkc, a co dopiero ...

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]
Kluski 9
źródło
Zamiast używać append, użyj += data,końcowego przecinka pośrednio tworzy krotkę, która jest następnie łączona z listą, dodając dane jako ostatni element na liście. W tym kontekście wykonajr+=l[i:j+1][::-1],
FlipTack
0

Python 2, 74 bajty

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

Wejście a, wyjściec

Siergiej Patiakin
źródło
0

Python 3, 191 bajtów

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)

Nie jestem pewien, czy używanie sortedfunkcji sprawdzania jest tutaj dozwolone, ale nie mogłem wymyślić żadnego dobrego powodu, aby obniżyć moją liczbę bajtów o ~ 30 bajtów.

sonrad10
źródło
0

Clojure, 105 bajtów

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

Partycji w parach o kolejnych numerach, wkłada truelub falsemiędzy nimi, partycje notdo truei numery stać falsei false trueodwraca partycje i zachowuje wartości liczbowych.

NikoNyrh
źródło