Thử thách

Cho một mảng số nguyên không trống, ví dụ:

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

Đầu tiên cắt nó thành các mảng trong đó không có mục nào lớn hơn các mảng trước (tức là các mảng không tăng dần):

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

Tiếp theo, đảo ngược từng mảng:

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

Cuối cùng, nối tất cả chúng lại với nhau:

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

Đây phải là những gì chương trình đầu ra / chức năng của bạn trả về. Lặp lại thủ tục này đủ số lần và mảng sẽ được sắp xếp đầy đủ.

Quy tắc

• Đầu vào và đầu ra có thể được cung cấp thông qua bất kỳ phương pháp tiêu chuẩn nào, và có thể ở bất kỳ định dạng mảng hợp lý nào.
• Mảng đầu vào sẽ không bao giờ trống, nhưng có thể chứa các phủ định và / hoặc trùng lặp.
• Giá trị tuyệt đối của mỗi số nguyên sẽ luôn nhỏ hơn 2 ³¹ .

Các trường hợp thử nghiệm

Hy vọng những điều này bao gồm tất cả các trường hợp cạnh:

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

Chấm điểm

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte sẽ thắng.

JavaScript (ES6), 64 byte

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

Đệ quy FTW! Thuật toán cơ bản được sử dụng ở đây là để theo dõi hoạt động không tăng dần hiện tại trong một mảng, "trả lại" nó bất cứ khi nào tìm thấy phần tử tăng dần. Chúng tôi làm điều này một cách đệ quy, liên tục nối các kết quả, cho đến khi chúng tôi hết các mục. Bằng cách tạo mỗi lần chạy ngược lại ( [n,...z]thay vì [...z,n]), chúng ta có thể tránh được việc kéo dài .reverse()mà không mất phí.

Kiểm tra đoạn

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 byte

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

Hãy thử trực tuyến!

Thạch , 8 byte

Ṁ;<œṗ³UF

Hãy thử trực tuyến!

Giải trình:

Ṁ;         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

Chắc chắn, điều này đã bị đánh bại bởi câu trả lời ETHproductions , nhưng đó là điều tốt nhất tôi có thể đưa ra cho đến nay mà không cần sử dụng đệ quy.

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

Lưu ý: Khởi tạo cả hai rvà ocho cùng một đối tượng có r = o = []thể trông giống như một ý tưởng nguy hiểm. Nhưng nó an toàn để làm như vậy ở đây vì rngay lập tức được gán riêng thể hiện của nó (chứa phần tử đầu tiên của a) trong lần lặp đầu tiên với r = [n, ...r].

Các trường hợp thử nghiệm

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 byte

lidO>vYsGhXSOZ)

Đầu vào là một vectơ cột, với định dạng [5; 2; 7; 6; 4; 1; 3](dấu chấm phẩy là dấu phân cách hàng).

Hãy thử trực tuyến!

Lấy đầu vào [5; 2; 7; 6; 4; 1; 3]làm ví dụ.

Giải trình

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]

Toán học, 30 27 byte

^{3 byte được lưu do @Martin Ender .}

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

Chức năng ẩn danh. Lấy danh sách các số làm đầu vào và trả về danh sách các số làm đầu ra.

Python 2, 100 byte

Một môn đánh gôn thực sự khủng khiếp, nhưng tôi muốn đăng giải pháp của mình (một người không chỉ đơn giản là vượt qua 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

Kiểm tra trên repl.it!

Đầu vào phải được đưa ra dưới dạng một danh sách Python theo nghĩa đen, chẳng hạn như [5, 3, 4, 2, 6, 1].

Ý tưởng cơ bản là sử dụng nhiều cú pháp cắt của Python, cắt từng phần cần thiết từ mảng, đảo ngược nó và thêm nó vào mảng mới.

Pyke, 11 8 byte ( phiên bản cũ )

$0m<fm_s

Hãy thử nó ở đây! (hoạt động trên phiên bản mới nhất)

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

Võng mạc , 163 byte

Vâng, tôi biết điều này kinh khủng như thế nào. Hỗ trợ số không và tiêu cực là siêu vui vẻ. Số lượng byte giả định mã hóa 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

Dùng thử trực tuyến

Giải trình:

\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 byte

Đã lưu 2 byte bằng thủ thuật sắp xếp của Luis Mendo

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

Hãy thử trực tuyến!

Giải trình

Ví dụ đầu vào [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]

Giải pháp 16 byte trước đó

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

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

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

Biểu thức Lambda có một Arraytham số duy nhất , a.

Cảm ơn @ETHproductions đã giúp tôi nhìn thấy sai lầm đầu tiên của mình.

Ruby, 60 55 byte

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

Khá nhiều những gì thách thức yêu cầu. Tôi đã định nghĩa một lambda s, lấy một mảng xvà sever (lát) nó thành các phần nhỏ hơn trong đó phần tử sau sẽ lớn hơn. Điều này trả lại một điều tra viên, mà chúng ta có thể gọi bản đồ trên và đảo ngược thứ tự của các mảnh, trước khi cuối cùng kết hợp tất cả lại với flatten, nối các phần tử theo thứ tự được xác định thành một mảng.

Xét nghiệm

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 byte

~c:{>=r}ac

Hãy thử trực tuyến!

Giải trình

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

APL Dyalog , 7 15 byte

Yêu cầu ⎕ML←3, được mặc định trên nhiều hệ thống. *

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

∊ tranh thủ (làm phẳng)

⌽¨ mỗi lần đảo ngược

⍵⊂⍨ đối số được phân vùng * bằng cách cắt trong đó mỗi phần tử tương ứng lớn hơn phần tử trước

1+ một cộng

⍵- đối số trừ

⌊/⍵ phần tử nhỏ nhất của đối số

Giải pháp 7 byte cũ không thành công với số nguyên không tích cực:

Yêu cầu ⎕ML←3, được mặc định trên nhiều hệ thống. *

∊⌽¨⊆⍨⎕

∊ tranh thủ (làm phẳng)

⌽¨ mỗi lần đảo ngược

⊂⍨ tự phân vùng *

* Phân vùng ( ⊂) là một hàm cắt đối số bên phải của nó trong đó đối số bên trái tương ứng lớn hơn đối số trước. (Thật không may, nó chỉ chấp nhận các số nguyên không âm và số 0 có ý nghĩa đặc biệt.) Từ phiên bản 16, chức năng ⊂này có sẵn trên tất cả các hệ thống (ngay cả những nơi có ⎕ML≠3), sử dụng glyph ⊆.

Haskell, 49 byte

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

Ví dụ sử dụng: (%[]) [5,2,7,6,4,1,3]-> [2,5,1,4,6,7,3].

Phương pháp đệ quy. Hàm %lấy danh sách đầu vào làm tham số đầu tiên và bộ tích lũy ltheo dõi khối không tăng dần cho đến nay (theo thứ tự ngược lại). Trường hợp cơ sở đạt được khi danh sách đầu vào trống và sau đó kết quả là bộ tích lũy. Nếu danh sách đầu vào không trống và phần tử đầu tiên akhông khớp với đoạn hiện tại ( any(<a)l), hãy trả lại bộ tích lũy và nối một cuộc gọi đệ quy trên phần còn lại của danh sách và adưới dạng bộ tích lũy mới ( l++b%[a]). Khác, thực hiện một cuộc gọi đệ quy trên phần còn lại của danh sách và được athêm vào để tích lũy ( b%(a:l)). Hàm chính (%[])gọi %với một bộ tích lũy trống.

Võng mạc , 98 byte

Số lượng byte giả định mã hóa ISO 8859-1.

$

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

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

Hãy thử trực tuyến!

R, 64 byte

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

Đọc đầu vào từ stdin. Chúng tôi chia đầu vào thành một danh sách các vectơ bằng cách sử dụng split()một biến nhân tố để nhóm đầu vào. Yếu tố được tạo ra bằng cách lấy tổng tích lũy của vectơ logic mà sự khác biệt là dương.

Hãy xem xét các vectơ:

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

Bây giờ lấy sự khác biệt và chuẩn bị trước Fbằng cách chạy y=c(F,diff(x)>0)sẽ tạo ra vectơ logic sau:

[1] FALSE FALSE  TRUE FALSE FALSE FALSE  TRUE

Lấy tổng tích lũy cumsum(y)tạo ra một vectơ trong đó mỗi nhóm được biểu diễn bằng một yếu tố duy nhất mà chúng ta có thể kết hợp với splithàm:

[1] 0 0 1 1 1 1 2

Octave, 75 44 byte

Dựa trên câu trả lời MATL của @LuisMendo

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

Hãy thử trực tuyến!

Câu trả lời trước

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

Hãy thử trực tuyến!

đảo ngược mảng

f=fliplr(a)

khác biệt đầu tiên của f

d = diff(f);

tìm vị trí nơi phần tử tiếp theo nhỏ hơn phần tử trước

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

sự khác biệt đầu tiên của các vị trí trả về độ dài của mỗi mảng phụ

len=diff(p)

sử dụng chiều dài của mỗi mảng con mat2cellđể phân chia mảng thành danh sách các mảng lồng nhau

nest = mat2cell(f,1,len);

đảo ngược danh sách lồng nhau

rev_nest = fliplr(nest) 

làm phẳng danh sách lồng nhau

[rev_nest{:}]

Pyth - 15 byte

s_McQf<@QtT@QTU

Hãy thử trực tuyến tại đây .

Perl 6 , 59 byte

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

Giải pháp dựa trên Regex.
Bởi vì đây là Sparta Perl !!

• m/ /: Sắp xếp chuỗi mảng đầu vào và khớp với biểu thức chính quy với nó.
• (\-? \d+): Ghép một số và bắt nó là $0.
• <?{ [>=] $0 }>: Xác nhận độ rộng bằng không chỉ khớp nếu tất cả $0được chụp cho đến nay trong trận đấu phụ hiện tại theo thứ tự không tăng dần.
• ([ ] +)+: Lặp lại hai bước cuối cùng thường xuyên nhất có thể, nếu không thì bắt đầu một trận đấu phụ mới.
• map , [0]: Lặp lại các trận đấu phụ.
• |+«*.[0].reverse: Đối với mỗi một, lấy danh sách các giá trị khớp với $0, đảo ngược nó, ép buộc các giá trị thành số ( +«) và trượt chúng vào danh sách bên ngoài ( |).

Perl 6 , 63 byte

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

Giải pháp xử lý danh sách đệ quy.
Lao động nhiều hơn tôi đã hy vọng.
Mặc dù ngôn ngữ có rất nhiều tiện ích tích hợp thuận tiện, dường như không có ngôn ngữ nào để phân vùng danh sách (ví dụ như của Ruby slice_whenhoặc Haskell takeWhile).

Xếp chồng , không biên dịch, 34 byte

Vẫn không ngừng phát triển ngôn ngữ này.

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

Luận cứ nằm trên ĐKDV. Hãy thử nó ở đây!

chunkbynhận một hàm và thu thập các mảng dữ liệu liền kề thỏa mãn hàm đó. Hàm sau đó là:

{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

Điều này cung cấp cho một mảng giảm nghiêm ngặt.

$revmapvề cơ bản [rev]mapvà đảo ngược từng mục.

flat cuối cùng làm phẳng mảng.

Một số niềm vui để thực sự sắp xếp mảng:

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

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

Đầu ra này (ví dụ):

(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 byte

Đã lưu 12 byte nhờ vào @ Flp.Tkc!

Không nơi nào gần @ Flp.Tkc, hãy để một mình ...

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 byte

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

Đầu vào a, đầu ra trongc

Python 3, 191 byte

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)

Tôi không chắc việc sử dụng sortedchức năng để kiểm tra có được phép ở đây hay không, nhưng tôi không thể nghĩ ra lý do chính đáng nào để chống lại nó và nó đã làm giảm số byte của tôi xuống ~ 30 Byte.

Clojure, 105 byte

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

Phân vùng thành cặp trên số thứ tự, puts truehoặc falsegiữa chúng, phân vùng trên notđể truevà số trở falsevà false true, đảo ngược các phân vùng và giữ các giá trị số.