ท้าทาย

รับอาร์เรย์ของจำนวนเต็มที่ไม่ว่างเปล่าเช่น:

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

ก่อนอื่นให้แบ่งเป็นอาร์เรย์โดยที่ไม่มีรายการใดใหญ่ไปกว่าอาร์เรย์ก่อนหน้า (เช่นอาร์เรย์ที่ไม่ได้เรียงจากน้อยไปมาก)

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

ถัดไปย้อนกลับแต่ละอาร์เรย์:

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

สุดท้ายเชื่อมพวกมันเข้าด้วยกัน:

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

นี่คือสิ่งที่โปรแกรมของคุณส่งออก / ฟังก์ชั่นกลับมา ทำซ้ำขั้นตอนนี้เพียงพอเวลาและอาร์เรย์จะเรียงลำดับอย่างสมบูรณ์

กฎระเบียบ

• อินพุตและเอาต์พุตอาจได้รับผ่านวิธีการมาตรฐานและอาจอยู่ในรูปแบบอาเรย์ที่เหมาะสม
• อาร์เรย์อินพุตจะไม่ว่างเปล่า แต่อาจมีเชิงลบและ / หรือซ้ำกัน
• ค่าสัมบูรณ์ของแต่ละจำนวนเต็มจะเป็นน้อยกว่า 2 วันที่ 31

กรณีทดสอบ

หวังว่าสิ่งเหล่านี้จะครอบคลุมกรณีขอบทั้งหมด:

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

เกณฑ์การให้คะแนน

นี่คือโค้ดกอล์ฟดังนั้นโค้ดที่สั้นที่สุดในหน่วยไบต์ชนะ

JavaScript (ES6), 64 ไบต์

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

การเรียกซ้ำ FTW! อัลกอริธึมพื้นฐานที่ใช้ในที่นี้คือการติดตามการทำงานแบบไม่ขึ้น - ลงปัจจุบันในอาเรย์ "คืนค่า" เมื่อใดก็ตามที่พบองค์ประกอบที่น้อยไปหามาก เราทำสิ่งนี้ซ้ำ ๆ กันเชื่อมผลลัพธ์อย่างต่อเนื่องจนกว่าเราจะหมดรายการ ด้วยการสร้างการย้อนกลับแต่ละครั้ง ( [n,...z]แทน[...z,n]) เราสามารถหลีกเลี่ยงความยาวได้.reverse()โดยไม่มีค่าใช้จ่าย

ตัวอย่างการทดสอบ

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 ไบต์

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

ลองออนไลน์!

เยลลี่ขนาด 8 ไบต์

Ṁ;<œṗ³UF

ลองออนไลน์!

คำอธิบาย:

Ṁ;         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 ไบต์

แน่นอนว่าคำตอบนี้ได้ถูกเอาชนะไปแล้วโดยETHproductionsแต่นั่นเป็นสิ่งที่ดีที่สุดที่ฉันสามารถทำได้โดยไม่ต้องใช้การสอบถามซ้ำ

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

หมายเหตุ: การเริ่มต้นทั้งสองrและoไปยังวัตถุเดียวกันแน่นอนกับr = o = []อาจมีลักษณะเหมือนเป็นความคิดที่อันตราย แต่มันมีความปลอดภัยที่จะทำที่นี่เพราะrได้รับมอบหมายทันทีเช่นของตัวเอง (ที่มีองค์ประกอบแรกของa) r = [n, ...r]บนซ้ำครั้งแรกกับ

กรณีทดสอบ

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 ไบต์

lidO>vYsGhXSOZ)

อินพุตเป็นเวกเตอร์คอลัมน์พร้อมรูปแบบ[5; 2; 7; 6; 4; 1; 3](อัฒภาคคือตัวคั่นแถว)

ลองออนไลน์!

นำเข้า[5; 2; 7; 6; 4; 1; 3]เป็นตัวอย่าง

คำอธิบาย

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 ไบต์

^{3 ไบต์บันทึกไว้เนื่องจาก@ Martin พลิก}

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

ฟังก์ชั่นไม่ระบุชื่อ รับรายการตัวเลขเป็นอินพุตและส่งคืนรายการตัวเลขเป็นเอาต์พุต

Python 2, 100 ไบต์

สนามกอล์ฟที่น่ากลัวจริงๆ แต่ฉันต้องการโพสต์วิธีแก้ปัญหาของฉัน(หนึ่งไม่เพียง outgolf 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

ทดสอบ repl.it!

[5, 3, 4, 2, 6, 1]การป้อนข้อมูลควรจะได้รับเป็นรายการที่แท้จริงงูใหญ่เช่น

แนวคิดพื้นฐานคือการใช้ประโยชน์จากไวยากรณ์การแบ่งของ Python อย่างหนักตัดส่วนที่จำเป็นแต่ละส่วนออกจากอาร์เรย์กลับด้านและเพิ่มเข้าไปในอาร์เรย์ใหม่

Pyke 11 8 ไบต์ ( เวอร์ชั่นเก่า )

$0m<fm_s

ลองที่นี่! (ใช้ได้กับเวอร์ชั่นล่าสุด)

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

เรติน่า 163 ไบต์

ใช่ฉันรู้ว่าเรื่องนี้น่ากลัวเพียงใด การสนับสนุนค่าศูนย์และค่าลบนั้นสนุกสุดๆ จำนวนไบต์ถือว่าการเข้ารหัส 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+                         # 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 ไบต์

บันทึก 2 ไบต์โดยใช้เคล็ดลับการจัดเรียงของ Luis Mendo

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

ลองออนไลน์!

คำอธิบาย

ตัวอย่างอินพุต [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]

โซลูชัน 16 ไบต์ก่อนหน้า

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

JavaScript (ECMA 6), 121 128 125 119 108 ไบต์

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

นิพจน์แลมบ์ดาใช้Arrayพารามิเตอร์เดียว, a.

ขอบคุณ @ETHproductions ที่ช่วยให้ฉันเห็นความผิดพลาดครั้งแรกของฉัน

Ruby, 60 55 ไบต์

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

ค่อนข้างท้าทายในสิ่งที่ขอ ฉันกำหนดแลมบ์ดาsซึ่งรับอาเรxย์และตัดเป็นชิ้นเล็ก ๆ โดยที่องค์ประกอบต่อไปนี้จะมากกว่า สิ่งนี้จะให้ตัวแจงนับกลับมาซึ่งเราสามารถเรียกใช้แผนที่บนและย้อนกลับลำดับของชิ้นส่วนก่อนที่จะนำมารวมเข้าด้วยกันด้วยความแบนซึ่งเชื่อมต่อองค์ประกอบต่างๆในลำดับที่กำหนดไว้ในอาร์เรย์เดียว

การทดสอบ

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 ไบต์

~c:{>=r}ac

ลองออนไลน์!

คำอธิบาย

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

Dyalog APL , 7 15 ไบต์

ต้องการ⎕ML←3ซึ่งเป็นค่าเริ่มต้นในหลาย ๆ ระบบ *

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

∊ เกณฑ์ (แบน)

⌽¨ แต่ละตรงกันข้าม

⍵⊂⍨ อาร์กิวเมนต์ที่แบ่งพาร์ติชัน * โดยการตัดโดยที่องค์ประกอบที่เกี่ยวข้องแต่ละรายการมีขนาดใหญ่กว่ารุ่นก่อน

1+ หนึ่งบวก

⍵- อาร์กิวเมนต์ลบ

⌊/⍵ องค์ประกอบที่เล็กที่สุดของการโต้แย้ง

โซลูชัน 7 ไบต์เก่าล้มเหลวด้วยจำนวนเต็มบวก:

ต้องการ⎕ML←3ซึ่งเป็นค่าเริ่มต้นในหลาย ๆ ระบบ *

∊⌽¨⊆⍨⎕

∊ เกณฑ์ (แบน)

⌽¨ แต่ละตรงกันข้าม

⊂⍨ ตนเองแบ่งพาร์ติชัน *

* Partition ( ⊂) เป็นฟังก์ชั่นที่ตัดอาร์กิวเมนต์ที่ถูกต้องโดยอาร์กิวเมนต์ซ้ายที่เกี่ยวข้องนั้นใหญ่กว่าอาร์กิวเมนต์ก่อนหน้า ( แต่น่าเสียดายที่มันยอมรับไม่ integers ลบและศูนย์มีความหมายพิเศษ.) จากรุ่น 16 ฟังก์ชั่นนี้⊂สามารถใช้ได้ในระบบทั้งหมด (แม้กระทั่งผู้ที่⎕ML≠3) ⊆โดยใช้สัญลักษณ์

Haskell, 49 ไบต์

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

ตัวอย่างการใช้งาน: ->(%[]) [5,2,7,6,4,1,3][2,5,1,4,6,7,3]

วิธีการแบบเรียกซ้ำ ฟังก์ชั่น%ใช้รายการอินพุตเป็นพารามิเตอร์แรกและแอคคูมูเลเตอร์lซึ่งติดตามส่วนที่ไม่ได้เรียงจากน้อยไปมาก (เรียงตามลำดับย้อนหลัง) ตัวพิมพ์ใหญ่จะมาถึงเมื่อรายการอินพุตว่างเปล่าจากนั้นผลลัพธ์จะเป็นตัวสะสม หากรายการอินพุตไม่ว่างเปล่าและองค์ประกอบแรกaไม่พอดีกับ chunk ปัจจุบัน ( any(<a)l) ให้ส่งคืนตัวสะสมและผนวกการเรียกแบบเรียกซ้ำในส่วนที่เหลือของรายการและaเป็นตัวสะสมใหม่ ( l++b%[a]) อื่นโทรซ้ำในส่วนที่เหลือของรายการและเตรียมที่aจะสะสม tha ( b%(a:l)) ฟังก์ชั่นหลัก(%[])เรียกใช้%ด้วยการสะสมที่ว่างเปล่า

เรติน่า 98 ไบต์

จำนวนไบต์ถือว่าการเข้ารหัส ISO 8859-1

$

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

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

ลองออนไลน์!

R, 64 ไบต์

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

อ่านอินพุตจาก stdin เราแบ่งอินพุตเป็นรายการของเวกเตอร์ที่ใช้split()ซึ่งต้องการตัวแปรตัวประกอบที่จัดกลุ่มอินพุต ปัจจัยถูกสร้างขึ้นโดยการหาผลรวมสะสมของเวกเตอร์ตรรกะซึ่งผลต่างนั้นเป็นค่าบวก

พิจารณาเวกเตอร์:

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

ตอนนี้การรับผลต่างและการเตรียมการล่วงหน้าFโดยการรันy=c(F,diff(x)>0)จะสร้างเวกเตอร์เชิงตรรกะดังต่อไปนี้:

[1] FALSE FALSE  TRUE FALSE FALSE FALSE  TRUE

การหาผลรวมสะสมcumsum(y)ก่อให้เกิดเวกเตอร์ซึ่งแต่ละกลุ่มจะถูกแทนด้วยปัจจัยเฉพาะซึ่งเราสามารถรวมเข้ากับsplitฟังก์ชั่น:

[1] 0 0 1 1 1 1 2

อ็อกเทฟ75 75ไบต์

ตามคำตอบ MATL ของ @LuisMendo

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

ลองออนไลน์!

คำตอบก่อนหน้า

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

ลองออนไลน์!

ย้อนกลับอาร์เรย์

f=fliplr(a)

ใช้ความแตกต่างแรกของ f

d = diff(f);

ค้นหาตำแหน่งที่องค์ประกอบถัดไปน้อยกว่าองค์ประกอบก่อนหน้า

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

ความแตกต่างแรกของตำแหน่งส่งคืนความยาวของแต่ละอาร์เรย์ย่อย

len=diff(p)

ใช้ความยาวของแต่ละอาร์เรย์ย่อยmat2cellเพื่อแยกอาร์เรย์เป็นรายการอาร์เรย์ที่ซ้อนกัน

nest = mat2cell(f,1,len);

กลับรายการที่ซ้อนกัน

rev_nest = fliplr(nest) 

แผ่รายการซ้อนกัน

[rev_nest{:}]

Pyth - 15 ไบต์

s_McQf<@QtT@QTU

ลองมันออนไลน์ได้ที่นี่

Perl 6 , 59 ไบต์

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

โซลูชันที่ใช้ Regex
เพราะนี่คือSparta Perl !!

• m/ /: ทำให้อาร์เรย์อินพุตเป็นสตริงและจับคู่ regex กับมัน
• (\-? \d+): $0ตรงกับตัวเลขและการจับเป็น
• <?{ [>=] $0 }>: การยืนยันความกว้างเป็นศูนย์ที่จะจับคู่ก็ต่อเมื่อการ$0จับภาพทั้งหมดในการจับคู่ย่อยปัจจุบันนั้นอยู่ในลำดับที่ไม่มากไปหาน้อย
• ([ ] +)+: ทำซ้ำสองขั้นตอนสุดท้ายบ่อยที่สุดเท่าที่จะทำได้หรือเริ่มการแข่งขันย่อยใหม่
• map , [0]: ทำซ้ำการแข่งขันย่อย
• |+«*.[0].reverse: สำหรับแต่ละรายการให้ใช้รายการค่าที่จับคู่$0ย้อนกลับบีบค่าให้เป็นตัวเลข ( +«) แล้วเลื่อนลงในรายการด้านนอก ( |)

Perl 6 , 63 ไบต์

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

โซลูชันการประมวลผลรายการแบบเรียกซ้ำ
ลำบากกว่าที่ฉันคาดไว้
แม้ว่าภาษานั้นมีตัวบิวด์อินที่สะดวกมากมายดูเหมือนจะไม่มีการแบ่งพาร์ติชันรายการ (เช่น Ruby's slice_whenหรือ Haskell's takeWhile)

แบบสแต็กไม่ใช่แบบ 34 ไบต์

ยังคงพัฒนาภาษานี้อย่างต่อเนื่อง

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

อาร์กิวเมนต์ตั้งอยู่บน TOS ลองที่นี่!

chunkbyรับฟังก์ชั่นและรวบรวมอาร์เรย์ของข้อมูลที่ต่อเนื่องที่ตอบสนองการใช้งาน ฟังก์ชั่นนั้นคือ:

{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

สิ่งนี้จะทำให้อาร์เรย์ลดลงอย่างเคร่งครัด

$revmapเป็นพื้น[rev]mapและกลับรายการแต่ละรายการ

flat ในที่สุดแบนอาร์เรย์

ความสนุกในการเรียงลำดับอาร์เรย์:

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

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

เอาต์พุตนี้ (ตัวอย่าง):

(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 151 Bytes

บันทึก 12 ไบต์ด้วย @ Flp.Tkc!

ไม่มีที่ไหนเลยใกล้ @ Flp.Tkc นับประสา ...

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 ไบต์

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

อินพุตa, เอาต์พุตในc

Python 3, 191 ไบต์

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)

ฉันไม่แน่ใจว่าsortedอนุญาตให้ใช้ฟังก์ชั่นตรวจสอบที่นี่ แต่ฉันไม่สามารถคิดได้ว่ามีเหตุผลที่ดีกับมันหรือไม่

Clojure 105 ไบต์

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

พาร์ทิชันเป็นคู่ที่หมายเลขติดต่อกันทำให้trueหรือfalseระหว่างพวกเขาพาร์ติชันบนnotไปtrueและตัวเลขกลายเป็นfalseและfalse trueพาร์ทิชันหลีและช่วยให้ค่าตัวเลข