ตามที่อธิบายไว้ในคำถามนี้ :

Dropsort ซึ่งออกแบบโดย David Morgan-Mar เป็นตัวอย่างของ "อัลกอริทึมการเรียงลำดับ" แบบ linear-time ที่สร้างรายการที่จริงแล้วเรียงลำดับแล้ว แต่มีองค์ประกอบดั้งเดิมบางส่วนเท่านั้น องค์ประกอบใด ๆ ที่ไม่ได้มีขนาดใหญ่เท่ากับองค์ประกอบสูงสุดก่อนหน้านั้นจะถูกลบออกจากรายการและทิ้งไป

หากต้องการใช้หนึ่งในกรณีทดสอบของพวกเขาอินพุตของ{1, 2, 5, 4, 3, 7}อัตราผลตอบแทน{1, 2, 5, 7}เป็น4และ3มีทั้งที่ปรับตัวลดลงเป็นขนาดเล็กกว่าก่อนหน้านี้ "เรียง" 5ค่า

เราไม่ต้องการอัลกอริทึม "การเรียงลำดับ" เราต้องการให้มันเป็นข้อตกลงที่แท้จริง ดังนั้นฉันต้องการให้คุณเขียนโปรแกรมที่ให้รายการตัวเลขแสดงรายการของรายการ DropSorted (เพื่อเป็นอัลกอริธึมการเรียงลำดับที่สมบูรณ์เราจะต้องรวมรายการเหล่านี้ แต่ การรวมรายการที่เรียงสองรายการก่อนหน้านี้และ การขอให้คุณทำอีกครั้งเป็นการถามคำถามสองคำถามดังนั้นคำถามนี้เป็นขั้นตอน "แยก" ของ DropSort ที่สมบูรณ์ของเราโดยเฉพาะ)

อย่างไรก็ตามการจัดเรียงและเนื้อหาของรายการของเราเป็นสิ่งสำคัญ ผลลัพธ์ของโปรแกรมของคุณจะต้องเทียบเท่ากับผลลัพธ์ของ DropSort ตามด้วย DropSort ของค่าที่ถูกทิ้งและอื่น ๆ จนกว่าคุณจะมีรายการของ chain เรียงลำดับเท่านั้น อีกครั้งให้ยืมชุดทดสอบที่มีอยู่ (และเพิ่มอีกสองรายการ):

Input                  -> Output
{1, 2, 5, 4, 3, 7}     -> {{1, 2, 5, 7}, {4}, {3}}
{10, -1, 12}           -> {{10, 12}, {-1}}
{-7, -8, -5, 0, -1, 1} -> {{-7, -5, 0, 1}, {-8, -1}}
{9, 8, 7, 6, 5}        -> {{9}, {8}, {7}, {6}, {5}}
{10, 13, 17, 21}       -> {{10, 13, 17, 21}}
{10, 10, 10, 9, 10}    -> {{10, 10, 10, 10}, {9}}  //Note equivalent values aren't dropped
{5, 4, 3, 8, 7, 6}     -> {{5, 8}, {4, 7}, {3, 6}}
{0, 2, 5, 4, 0, 7}     -> {{0, 2, 5, 7}, {4}, {0}}

คุณอาจสันนิษฐานว่าอินพุตไม่ว่างเปล่า

นี่คือรหัสกอล์ฟดังนั้นจึงใช้กฎมาตรฐาน!

MATL , 15 10 9 ไบต์

ปิด 5 ไบต์โดยใช้แนวคิดของ@beakerเกี่ยวกับค่าสูงสุดสะสม

t"ttY>=&)

อินพุตเป็นเวกเตอร์แถวที่เป็นตัวเลขในรูปแบบ [1, 2, 5, 4, 3, 7] (คอมมาเป็นตัวเลือก) เอาต์พุตมีรายการคั่นด้วยบรรทัดใหม่โดยตัวเลขในแต่ละรายการคั่นด้วยช่องว่าง

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมดตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย

รับอาร์เรย์รหัสเลือกจากมันทุกรายการที่เท่ากับจำนวนสะสมสูงสุดถึงรายการนั้น

ตัวอย่างเช่นกำหนด

1 2 5 4 3 7

รหัสจะเลือกรายการแรกที่สองที่สามและที่หก:

1 2 5     7

จากนั้นกระบวนการจะทำซ้ำใน subarray ที่เกิดขึ้นจากรายการที่เหลือ (ในลำดับเดิม):

      4 3

สิ่งนี้จะต้องทำจนกว่า subarray ของรายการที่เหลือจะว่างเปล่า ขอบเขตบนของจำนวนการวนซ้ำที่ต้องการคือขนาดอินพุต การทำซ้ำครั้งล่าสุดอาจไม่จำเป็น ในกรณีนั้นมันทำงานกับอาเรย์ที่ว่างเปล่าซึ่งจะสร้างอาเรย์ที่ว่างเปล่าเพิ่มเติม

ในตอนท้ายสแต็กจะมีอาร์เรย์ที่จำเป็นและอาจมีหลายอาร์เรย์ที่ว่างเปล่าซึ่งจะไม่แสดงเลย

t        % Implicit input. Duplicate
"        % Do as many times as the input size
  tt     %   Duplicate twice
  Y>     %   Cumulative maximum
  =      %   Compare for equality. Will be used as logical index
  &)     %   Two-output indexing: pushes indexed subarray, and then
         %   a subarray with the remaining entries
         % End (implicit)
         % Display stack (implicit). Empty arrays are not displayed

Haskell, 67 59 58 ไบต์

(q:r)!x|x<last q=q:r!x|1<2=(q++[x]):r
_!x=[[x]]
foldl(!)[]

คำอธิบาย:ได้รับรายชื่อของรายการ (นั่นจะเรียงแล้ว) และค่าxที่!ผู้ประกอบการจะวางในตอนท้ายของรายการแรกที่มีองค์ประกอบสุดท้ายคือน้อยกว่าหรือเท่ากับx xหากไม่มีรายการดังกล่าวรายการ[x]จะถูกวางไว้ที่ท้าย

ลองออนไลน์

Huskขนาด 10 ไบต์

hUmü<¡Ṡ-ü<

ลองออนไลน์!

นี่คือการรวมกันของคำตอบแกลบอื่น ๆ ของฉันและXNOR คำตอบของ ซ้ำกันü<รู้สึก clunky แต่ฉันไม่รู้วิธีกำจัดมัน ...

คำอธิบาย

ฟังก์ชันü<แปลเป็นภาษาnubBy(>)Haskell มันสำรวจรายการจากซ้ายไปขวาทำให้องค์ประกอบเหล่านั้นซึ่งองค์ประกอบที่ไม่ได้เก็บไว้ก่อนหน้านั้นยิ่งใหญ่กว่าอย่างเคร่งครัด มันจะทำการลดลง ü<องค์ประกอบที่เหลือจะได้รับจากความแตกต่างการจดรายชื่อของรายการเดิมและผลมาจากการ

hUmü<¡Ṡ-ü<  Implicit input, say x = [2,3,5,4,4,2,7].
     ¡      Iterate
      Ṡ-    list difference between argument
        ü<  and its dropsort: [[2,3,5,4,4,2,7],[4,4,2],[2],[],[],[],...
  m         Map
   ü<       dropsort: [[2,3,5,7],[4,4],[2],[],[],[],...
 U          Prefix of unique elements: [[2,3,5,7],[4,4],[2],[]]
h           Drop last element: [[2,3,5,7],[4,4],[2]]

Haskell , 50 ไบต์

import Data.List
f[]=[]
f l|r<-nubBy(>)l=r:f(l\\r)

ลองออนไลน์!

Husk , 16 ไบต์

hUm₁≤¡₁>
ṠfSz⁰G▲

ลองออนไลน์!

คำอธิบาย

บรรทัดแรกนี้เป็นฟังก์ชั่นหลักและที่สองคือฟังก์ชั่นตัวช่วยคำสั่งที่สูงกว่า (ใช้ฟังก์ชันเป็นอาร์กิวเมนต์และส่งคืนฟังก์ชันใหม่) ₁มันเข้าถึงได้โดยห้อย ความคิดคือ₁≤การดำเนินการ Dropsort และ₁>ให้องค์ประกอบที่เหลือ

ṠfSz⁰G▲  Helper function, takes binary function p (as ⁰) and list x (implicit).
         For example, p = (≤) and x = [2,4,3,4,5,2].
     G▲  Left scan on x with maximum: [2,4,4,4,5,5].
  Sz     Zip with x
    ⁰    using the function p: [1,1,0,1,1,0].
Ṡf       Keep elements of x at truthy indices: [2,4,4,5].

ในฟังก์ชั่นหลักเราวนฟังก์ชั่นที่เหลือ₁>และใช้ฟังก์ชั่น Dropsort ₁≤กับผลลัพธ์

hUm₁≤¡₁>  Main function, implicit list argument, say x = [2,4,3,4,5,2].
     ¡    Iterate
      ₁>  the leftovers function: [[2,4,3,4,5,2],[3,2],[2],[],[],[],...
  m       Map
   ₁≤     the dropsort function: [[2,4,4,5],[3],[2],[],[],[],...
 U        Prefix of unique elements: [[2,4,4,5],[3],[2],[]]
h         Drop last element (an empty list): [[2,4,4,5],[3],[2]]

Python 3 , 131 112 103 95 ไบต์

ขอบคุณมาก @Mr Xcoder ยอดเยี่ยม 19 ไบต์ !!

ขอบคุณ @ovs มากสำหรับ 17 ไบต์ที่น่าทึ่ง!

def f(x):
 a,*x=x or[0];m=[a];d=[]
 for i in x:[m,d][i<m[-1]]+=i,
 return[m]+(x and(d>[])*f(d))

ลองออนไลน์!

คำอธิบาย:

def f(x):               #recursive function taking list, returns list of lists 
 if len(x)<2:return[x]  #for a single element return [element] 
 m=[x[0]];d=[]          #initialize main and dropped lists
 for i in x[1:]:[m,d][i<m[-1]]+=[i]  #append elements from the argument list accordingly into main and dropped list 
 return[m]+(d>[])*list(f(d)) #add main-list along with further evaluated dropped-list(recursived) into a list of lists

Haskell , 113 107 102 92 ไบต์

import Data.List
a!(b:c)|b<last a=a!c|1>0=a++[b]!c
a!b=a
g x@(b:c)|i<-[b]!c=i:g(x\\i)
g x=[]

ลองออนไลน์!

นี้รู้สึกจริงๆยาว

คำอธิบาย

!ดำเนินการจัดเรียงแบบหล่นในรายการในขณะที่#รวบรวมการตัดแต่ง gจากนั้นนำ#ไปใช้ซ้ำ ๆจนกระทั่งรายการว่างเปล่าบันทึกผลลัพธ์ในรายการ

APL, 27 ไบต์

{⍵≡⍬:⍬⋄(⊂X/⍵),∇⍵/⍨~X←⍵≥⌈\⍵}

คำอธิบาย:

• ⍵≡⍬:⍬: ถ้าอินพุตว่างให้ส่งคืนรายการว่าง
• X←⍵≥⌈\⍵: ตัวเลขทั้งหมดที่มากกว่าหรือเท่ากับค่าสูงสุดที่ใช้งาน
• (⊂X/⍵): รายการหมายเลขเหล่านั้น
• ∇⍵/⍨~X: ตามด้วยผลลัพธ์ของการเรียกใช้ฟังก์ชันนี้กับจำนวนที่เหลืออยู่

JavaScript (ES6), 64 ไบต์

f=(a,l,r=[])=>a+a&&[a.filter(e=>e<l?!r.push(e):(l=e,1)),...f(r)]

Ungolfed:

f=(a,l,r=[])=>
  a+a&&                                    //any elements left?
  [a.filter(                               //filter elements that are in order,
    e=>e<l?!r.push(e):(l=e,1)              //push unsorted elements to r
   ),                                      //push() returns the new length of the array,
                                           //... so !push() will always return false
   ...f(r)                                 //recurse on r
  ]

f=(a,l,r=[])=>a+a&&[a.filter(e=>e<l?!r.push(e):(l=e,1)),...f(r)]

console.log(JSON.stringify(f([1, 2, 5, 4, 3, 7])));     // [1, 2, 5, 7][4][3]
console.log(JSON.stringify(f([10, -1, 12])));           // [10, 12][-1]
console.log(JSON.stringify(f([-7, -8, -5, 0, -1, 1]))); // [-7, -5, 0, 1][-8, -1]
console.log(JSON.stringify(f([9, 8, 7, 6, 5])));        // [9][8][7][6][5]
console.log(JSON.stringify(f([10, 13, 17, 21])));       // [10, 13, 17, 21]
console.log(JSON.stringify(f([10, 10, 10, 9, 10])));    // [10, 10, 10, 10][9]
console.log(JSON.stringify(f([5, 4, 3, 8, 7, 6])));     // [5, 8][4, 7][3, 6]
console.log(JSON.stringify(f([0, 2, 5, 4, 0, 7])));     // [0,2,5,7],[4],[0]

R , 61 ไบต์

f=function(x)if(sum(x|1)){print(x[b<-x==cummax(x)]);f(x[!b])}

ลองออนไลน์!

ฟังก์ชั่นวนซ้ำ sum(x|1)มีการจดชวเลขสำหรับlength(x)ดังนั้นการเรียกใช้ซ้ำนี้จะทำงานจนกว่าxจะว่างเปล่า cummaxใช้เวลาสะสมสูงสุดxซึ่งจะถูกนำมาเปรียบเทียบxอีกครั้ง สิ่งนี้สร้างเวกเตอร์บูลีนที่มีความยาวxโดยที่ TRUE ทั้งหมดสอดคล้องกับค่าที่เรียงลำดับ เราใช้ว่าจะใช้ชุดย่อยของxและprintมัน xฟังก์ชั่นจากนั้นจะเรียกว่าอีกครั้งในส่วนที่เหลือของ

Java 8, 182 179 177 ไบต์

import java.util.*;l->{List r=new Stack(),t;for(int p,i,x;l.size()>0;)for(p=l.get(0),r.add(t=new Stack()),i=0;i<l.size();p=x)if((x=l.get(i++))>=p)t.add(l.remove(--i));return r;}

-3 ไบต์ขอบคุณที่@Nevay
-2 ไบต์โดยใช้แทนStackVector

คำอธิบาย:

ลองที่นี่

import java.util.*;            // Required import for List and Vector
l->{                           // Method with ArrayList<Integer> parameter and List return-type
  List r=new Stack(),          //  Return-List
       t;                      //  Temp-List
  for(int p,i,x;               //  Some temp integers
      l.size()>0;)             //  Loop (1) as long as there are still items left in the list
    for(p=l.get(0),            //   Set `p` to the first item of the list
        r.add(t=new Stack()),  //   Add a new inner List to the result-List
        i=0;i<l.size();        //   Inner loop (2) from 0 to the size of the list (exclusive)
         p=x)                  //     After every iteration, save the previous value in `p`
      if((x=l.get(i++))>=p)    //    If the current item is equal or larger than the previous:
        t.add(l.remove(--i));  //     Add it to the temp-List, and remove it from the input-List
                               //   End of inner loop (2) (implicit / single-line body)
                               //  End of loop (1) (implicit / single-line body)
  return r;                    //  Return result-List
}                              // End of method

C #, 188 203 ไบต์

int[][]f(int[]a){int[]t=a.Where((n,i)=>i<1||n>=a[i-1]).ToArray(),m=a.Where((n,i)=>i>0&&n<a[i-1]).ToArray();var s=new int[][]{t}.ToList();if(m.Any())s.AddRange(f(m));return s.ToArray();}

จำนวนไบต์รวมถึง +18 สำหรับ:

using System.Linq;

ลองออนไลน์!

C ++ 14, 118 108 bytes

การใช้อัลกอริทึมจากw0lf เป็นคำตอบ

ในฐานะแลมบ์ดาทั่วไปที่ไม่มีชื่อ พารามิเตอร์แรกคือคอนเทนเนอร์ที่มีค่าเป็น Dropsort (เช่นvector<int>) และพารามิเตอร์ที่สองต้องการคอนเทนเนอร์เปล่าที่เข้ากันได้ของภาชนะ (เช่นvector<vector<int>>) สำหรับค่าส่งคืนผ่านการอ้างอิง

ในโปรแกรมเวอร์ชันแรกมีR.clear;()คำสั่งแรกเหมือนกันดังนั้นคอนเทนเนอร์ของคอนเทนเนอร์ไม่จำเป็นต้องว่างเปล่า Peter Cordes คิดว่านี่อาจเป็นข้อมูลจำเพาะดังนั้นให้ทิ้ง 10 ไบต์ลงไป

[](auto A,auto&R){for(auto x:A){for(auto&D:R)if(D.back()<x){D.push_back(x);goto F;}R.emplace_back(1,x);F:;}}

ลองออนไลน์!

Ungolfed:

[](auto A,auto&R){
 for(auto x:A){       //foreach item
  for(auto&D:R)       //foreach result list
   if(D.back()<x){    //x bigger than last element
    D.push_back(x);   //add x
    goto F;           //break and jump over the emplace
   }
  R.emplace_back(1,x);//create new list with this element
  F:;
 }
}

Python 2 , 88 ไบต์

-4 ไบต์ขอบคุณ Arnold Palmer

b,r=input(),[]
for i in b:
 for l in r:
	if l[-1]<=i:l+=[i];break
 else:r+=[[i]]
print r

ลองออนไลน์!

โซลูชันที่คล้ายกับ @ w0lf's haskell [answer] [1]

กรณีใช้งานที่หายากสำหรับ for-elseก่อสร้าง

วนซ้ำรายการที่จัดเรียงfor l in r(ว่างเมื่อเริ่มต้น)
หากองค์ประกอบ (จากอินพุต) iมีขนาดใหญ่กว่าองค์ประกอบสุดท้ายของรายการl[-1]ให้เพิ่มองค์ประกอบลงในรายการl+=[i]หยุดพัก
หากไม่ยอมรับรายการให้เพิ่มรายชื่อใหม่ด้วย elemens นี้r+=[[i]]

R, กำลังดำเนินการ (89, แต่ล้มเหลว)

ถืองานไว้ที่นี่เพราะฉันสนับสนุนตัวเองในมุมที่ใช้%in%(มันล้มเหลวในรายการที่ซ้ำกันโดยเฉพาะอย่างยิ่งกรณีทดสอบครั้งสุดท้าย) และฉันต้องไปทำอย่างอื่นตอนนี้ แต่นี่คือที่นี่ถ้าใครต้องการสร้างมัน:

z=function(x){if(length(x)){a=x[x>=cummax(x)]
append(list(a),z(x[!(x%in%a)]))}else{NULL}}

Ungolfed:

z=function(x){
  if(length(x)){
    a=x[x>=cummax(x)]
    append(list(a),z(x[!(x%in%a)]))
  } else {
    NULL
  }
}

JavaScript (ES6), 71 70 68 ไบต์

a=>a.map(n=>(o.find(b=>[...b].pop()<=n)||(n=[n],o)).push(n),o=[])&&o

ค่อนข้างง่ายเพียงวนซ้ำหาอาร์เรย์ภายในสุดที่มีค่าสุดท้าย <=ถัดไปที่จะลดลงหากไม่มีอยู่ให้ผนวกอาร์เรย์ภายในใหม่ที่มีค่าถัดไปเป็นเอาท์พุท พบอาร์เรย์ภายในที่ตรงกับเงื่อนไข

ปรับปรุง

ขอขอบคุณที่นีลที่บันทึกไว้สามไบต์แปลง(...,o)ไป...&&oและจัดระเบียบใหม่โทรกลับเพื่อmap()ให้กะทัดรัดมากขึ้น

f=a=>a.map(n=>(o.find(b=>[...b].pop()<=n)||(n=[n],o)).push(n),o=[])&&o;[[1,2,5,4,3,7],[10,-1,12],[-7,-8,-5,0,-1,1],[9,8,7,6,5],[10,13,17,21],[10,10,10,9,10],[5,4,3,8,7,6],[0,2,5,4,0,7]].map(f).map(JSON.stringify).map(v=>console.log(v))

.as-console-wrapper{max-height:100%!important}

Japt 29 ไบต์

@lOpP)<1}a@=f_<VªOoV=Z+S}V=Ug

ทดสอบออนไลน์!

C (gcc) , 176 175 173 ไบต์

#define P(x)printf("%d ",t=x);
l[2][99];t;x;i;j;w;main(a){while(scanf("%d",*l+w)>0)++w;while(i=w){P(l[a=!a][w=0])for(j=1;j<i;++j){x=l[a][j];x<t?l[!a][w++]=x:P(x)}puts("");}}

ลองออนไลน์!

รุ่นที่สามารถอ่านได้ค่อนข้าง:

#define P(x)printf("%d ",t=x);
l[2][99];t;x;i;j;w;
main(a)
{
    while(scanf("%d",*l+w)>0)++w;
    while(i=w)
    {
        P(l[a=!a][w=0])
        for(j=1;j<i;++j)
        {
            x=l[a][j];
            x<t?l[!a][w++]=x:P(x)
        }
        puts("");
    }
}

PHP, 91 103 96 85 ไบต์

(แก้ไขเพื่อเพิ่ม 12 ตัวอักษรจาก print_r($r);เพื่อตอบสนองความต้องการในการส่งออก)
(แก้ไขเพื่อลบ 7 ไบต์เมื่ออนุญาตให้มีข้อผิดพลาด PHP)
(แก้ไขเพื่อลบ 11 ไบต์เมื่อแก้ไขการมอบหมายเพิ่มเติม)

while($a){$b=$d=[];foreach($a as$i)${max($b)>$i?d:b}[]=$i;$a=$d;$r[]=$b;}print_r($r);

รับอินพุต$aมันสร้างผลลัพธ์$r

น่ารัก:

while ($a) {
    $b = $d = [];
    foreach ($a as $i) {
        ${max($b) > $i ? d : b}[] = $i;
    }
    $a   = $d;
    $r[] = $b;
}

การวนรอบนอกแบบหลอกซ้ำเริ่มต้นอาร์เรย์เก็บ$bและทิ้ง$dให้ว่างเปล่าจากนั้นทำการวนรอบการจัดเรียงแบบพื้นฐานในที่สุดก็ตั้งค่าทิ้งเป็นอินพุตใหม่และเพิ่มการเก็บไปยังผลลัพธ์$r

PHP , 102 ไบต์ , 98 ไบต์

<?php function s($i){static$s;foreach($i as$v)${$v<max($l)?f:l}[]=$v;$s[]=$l;!$f?:s($f);return$s;}

ลองออนไลน์!

-4 ไบต์ขอบคุณ @Umbrella

คำอธิบาย

<?php

ฟังก์ชั่นใช้รายการอินพุตเป็นอาร์เรย์

function s($i) {

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

    static $s;

วนซ้ำแต่ละค่าในรายการ

    foreach ($i as $v)

มันน้อยกว่าสมาชิกรายปัจจุบันที่ใหญ่ที่สุด?

        $v < max($l) ?

ใช่วางไว้ในรายการ$fสำหรับการเรียงลำดับเพิ่มเติม

                        $f[] = $v :

$lไม่ใส่ไว้ในรายการ

                        $l[] = $v;

กดลิสต์$lไปยังรายการลิสต์

    $s[] = $l;

หากมีสิ่งใดในรายการ$fให้ส่งรอบอีกครั้งเพื่อจัดเรียงเพิ่มเติม

    !$f ?: s($f);

ส่งคืนรายการ

    return $s;
}

Sage, 102 ไบต์

def f(w,a=[]):
 for x in w:
  q,c=exists(a,lambda b:b[-1]<=x)
  if q:c+=[x]
  else:a+=[[x]]
 return a

คล้ายกันมากกับ @Dead Possum ของคำตอบ
ต่อท้ายสมาชิกแต่ละคนxของwรายการแรกในa{list of list} ที่มีxมากกว่าองค์ประกอบสุดท้าย
ถ้าใครผนวกไป [x]a

ฉันต้องการมันถ้าexistsส่งคืนaถ้าไม่พบอะไรเลย! ลองใช้แนวคิดแบบบรรทัดเดียวของ @ officialaimm ด้วย ...

คำถาม: ถ้าฉันลบรหัสออกจากฟังก์ชันฉันต้องกำหนด wให้เข้าใช่มั้ย ดังนั้นจะช่วยประหยัดไบต์?

Ocaml , 69 62 ไบต์

let rec d=function h::i::t when h>i->d(h::t)|h::t->h::d t|x->x

คำอธิบาย:

let rec d = function (* Implicitly take an list as a parameter *)
    (* If the list starts with two elements h and i and h is greater than i, drop i and sort the list starting with h and the rest t *)
    | h::i::t when h > i -> d (h::t) 
    (* If h is not greater than i, make a new list starting with h and a tail containing the drop sorted rest *)
    | h::t -> h::d t
    (* If none of the cases apply, the list is empty. *)
    | x -> x

APL, 100 88 83 79 78 57 56 77 76 ไบต์

{(E/⍵),⊂⍵/⍨~E←(⍬≢⍴)¨⍵}∘{⍵≡(S←¯1↓⍵),⊃⊃⌽⍵:⍵⋄∇S,⊃⌽⍵}{⍵≡X←⍵/⍨~V←⍵≠⌈\⍵:⍵⋄X(∇V/⍵)}

-0 ไบต์ขอบคุณ Kritixi Lithos ...

ลองออนไลน์!

ต้องมีวิธีที่ดีกว่าในการทำสิ่งนี้ ( มี) ) เคล็ดลับใด ๆ ที่ชื่นชมอย่างมากและยินดีต้อนรับ

อย่างไร?

(หมายเหตุบางคำอธิบายนี้อาจผิดเพราะฉันลืมวิธีการทำงาน)

{⍵≡X←⍵/⍨~V←⍵≠⌈\⍵:⍵⋄X(∇V/⍵)} - separate the argument into nested drop-sorts
{⍵≡(S←¯1↓⍵),⊃⊃⌽⍵:⍵⋄∇S,⊃⌽⍵}  - un-nesting (passed the result of the above)
{(E/⍵),⊂⍵/⍨~E←(⍬≢⍴)¨⍵}∘     - fixing array mishaps (passed the result of the above)

เยลลี่ 26 ไบต์

<»\¬x@ðW;µ⁸Ñ
<»\x@µÑ
1Ŀ¹L?

นี่เป็นวิธีการเดียวกับคำตอบ APL ของ marinus

ลองออนไลน์! .

JavaScript (Node.js) , 125 109 106 ไบต์

- 16 bytes จากZacharý

-1 โดยการลบ {และ}โดยการเพิ่มตัวเพิ่มเพื่อรวม "set last to current"

m=x=>{z=[[],[]];l=NaN;for(i=0;i<x.length;l=x[i++])if(l>x[i])z[1].push(x[i]);else z[0].push(x[i]);return z}

โดยทั่วไปการถามคือรายการปัจจุบันที่มากกว่ารายการสุดท้ายให้เพิ่มในรายการแรก มิฉะนั้นเพิ่มไปที่สอง

พบออกมาในช่วงนี้ที่เปรียบเทียบจำนวนใด ๆ ที่จะส่งผลให้เกิดNaN false! ที่น่าสนใจ

คำอธิบาย:

m = x => {                         // Create function
  z = [[], []];                      // Initialize dropsort output
  l = NaN;                           // Initialize last element
  for (i = 0; i < x.length; l=x[i++])// For each item in input...
    if (l > x[i])                    // If current item is greater than previous
      z[1].push(x[i]);               // Then add it to the first part of output
    else                             // Elsewise
      z[0].push(x[i]);               // Add it to the nonordered part of the dropsort
                                     // Set last item to current item
  }                                  // Repeat
  return z                           // Return finished dropsort
}                                    // End function

ลองออนไลน์!