Như được mô tả trong câu hỏi này :

Dropsort, được thiết kế bởi David Morgan-Mar, là một ví dụ về "thuật toán sắp xếp" thời gian tuyến tính tạo ra một danh sách, trên thực tế, được sắp xếp, nhưng chỉ chứa một số yếu tố ban đầu. Bất kỳ yếu tố nào không lớn nhất bằng mức tối đa của các yếu tố trước nó sẽ bị xóa khỏi danh sách và bị loại bỏ.

Để sử dụng một trong các trường hợp thử nghiệm của họ, đầu vào của {1, 2, 5, 4, 3, 7}sản lượng {1, 2, 5, 7}, 4và 3cả hai đều bị loại bỏ vì nhỏ hơn giá trị "được sắp xếp" trước đó , 5.

Chúng tôi không muốn các thuật toán "sắp xếp", chúng tôi muốn chúng là thỏa thuận thực sự. Do đó, tôi muốn bạn viết một chương trình, đưa ra một danh sách các số, đưa ra một danh sách các danh sách DropSort (để trở thành một thuật toán sắp xếp hoàn chỉnh, chúng ta sẽ cần hợp nhất các danh sách này, nhưng việc hợp nhất hai danh sách đã sắp xếp đã được thực hiện trước đó và yêu cầu bạn làm lại một lần nữa là hỏi hai câu hỏi, vì vậy câu hỏi này cụ thể là bước "tách" của DropSort hoàn chỉnh của chúng tôi).

Tuy nhiên, sự sắp xếp và nội dung của danh sách của chúng tôi là rất quan trọng. Đầu ra của chương trình của bạn phải tương đương với đầu ra của DropSort, theo sau là DropSort của các giá trị bị loại bỏ, và cứ thế cho đến khi bạn chỉ có một danh sách các chuỗi được sắp xếp. Một lần nữa, mượn bộ kiểm tra hiện có (và thêm hai bộ nữa):

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

Bạn có thể giả sử đầu vào không trống.

Đây là mã golf , vì vậy các quy tắc tiêu chuẩn được áp dụng!

MATL , 15 10 9 byte

Giảm 5 byte bằng cách sử dụng ý tưởng tối đa tích lũy của @beaker

t"ttY>=&)

Đầu vào là một vectơ hàng số, ở định dạng [1, 2, 5, 4, 3, 7](dấu phẩy là tùy chọn). Đầu ra chứa các danh sách được phân tách bằng dòng mới, với các số trong mỗi danh sách được phân tách bằng dấu cách.

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

Đưa ra một mảng, mã chọn từ nó mỗi mục bằng với mức tối đa tích lũy cho đến mục đó.

Ví dụ, được đưa ra

1 2 5 4 3 7

mã chọn các mục đầu tiên, thứ hai, thứ ba và thứ sáu:

1 2 5     7

Sau đó, quá trình được lặp lại trên subarray được hình thành bởi các mục còn lại (theo thứ tự ban đầu):

      4 3

Điều này cần phải được thực hiện cho đến khi phân đoạn của các mục còn lại trống. Giới hạn trên của số lần lặp được yêu cầu là kích thước đầu vào. Các lần lặp lại cuối cùng có thể không cần thiết. Trong trường hợp đó, chúng hoạt động trên một mảng trống, tạo ra các mảng trống bổ sung.

Cuối cùng, ngăn xếp chứa các mảng cần thiết và có thể một số mảng trống, hoàn toàn không hiển thị.

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 byte

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

Giải thích: Đưa ra một danh sách các danh sách (đã được sắp xếp) và một giá trị x, !toán tử sẽ đặt xở cuối danh sách đầu tiên có phần tử cuối cùng nhỏ hơn hoặc bằng x. Nếu không có danh sách như vậy tồn tại, danh sách [x]được đặt ở cuối.

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

Husk , 10 byte

hUmü<¡Ṡ-ü<

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

Đây là sự kết hợp giữa câu trả lời Husk khác của tôi và câu trả lời Haskell của xnor . Bản sao ü<cảm thấy lộn xộn, nhưng tôi không biết làm cách nào để thoát khỏi nó ...

Giải trình

Các chức năng ü<dịch nubBy(>)trong Haskell. Nó đi qua một danh sách từ trái sang phải, giữ những yếu tố mà không có yếu tố nào được giữ trước đó là lớn hơn. Nói cách khác, nó thực hiện droport. Các yếu tố còn lại có được bằng cách lấy sự khác biệt danh sách của danh sách ban đầu và kết quả của ü<.

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 byte

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

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

Husk , 16 byte

hUm₁≤¡₁>
ṠfSz⁰G▲

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

Giải trình

Dòng đầu tiên này là hàm chính và dòng thứ hai là hàm trợ giúp bậc cao hơn (nó lấy một hàm làm đối số và trả về một hàm mới). Nó được truy cập bởi các mục con ₁. Ý tưởng là ₁≤thực hiện droport và ₁>đưa ra các yếu tố còn sót lại.

Ṡ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].

Trong chức năng chính, chúng tôi lặp lại chức năng thức ăn thừa ₁>và áp dụng chức năng droort ₁≤cho kết quả.

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 byte

Cảm ơn rất nhiều @Mr. Xcoder để phá vỡ 19 byte !!

Cảm ơn rất nhiều @ovs cho 17 byte tuyệt vời!

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

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

Giải trình:

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 byte

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

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

Điều này cảm thấy thực sự dài.

Giải trình

!thực hiện sắp xếp thả trong danh sách, trong khi #thu thập các trang trí. gsau đó lặp đi lặp lại áp dụng #cho đến khi danh sách trống ghi kết quả trong danh sách.

APL, 27 byte

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

Giải trình:

• ⍵≡⍬:⍬: nếu đầu vào trống, trả về danh sách trống
• X←⍵≥⌈\⍵: tất cả các số lớn hơn hoặc bằng mức tối đa đang chạy
• (⊂X/⍵): danh sách những con số đó,
• ∇⍵/⍨~X: theo sau là kết quả của việc chạy hàm này trên các số còn lại

JavaScript (ES6), 64 byte

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

Ung dung:

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 byte

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

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

Hàm đệ quy. sum(x|1)là viết tắt cho length(x), vì vậy đệ quy này sẽ chạy cho đến khi xtrống rỗng. cummaxlấy tối đa tích lũy của x, sau đó được so sánh với xmột lần nữa. Điều này tạo ra một vectơ có độ dài boolean x, trong đó tất cả các TRUE tương ứng với các giá trị được sắp xếp. Chúng tôi sử dụng nó để có một tập hợp con xvà printnó. Hàm này sau đó được gọi lại vào phần còn lại của x.

Java 8, 182 179 177 byte

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 byte nhờ @Nevay .
-2 byte bằng cách sử dụng Stackthay vì Vector.

Giải trình:

Hãy thử nó ở đây.

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 byte

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

Số lượng byte bao gồm +18 cho:

using System.Linq;

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

C ++ 14, 118 108 byte

Sử dụng thuật toán từ câu trả lời Haskell của w0lf .

Như lambda chung không tên. Tham số đầu tiên là một thùng chứa các giá trị cho droport (như vector<int>) và tham số thứ hai yêu cầu một thùng chứa rỗng tương thích (thích vector<vector<int>>) cho giá trị trả về thông qua tham chiếu.

Trong phiên bản đầu tiên của chương trình, đã có R.clear;()tuyên bố đầu tiên, do đó, thùng chứa các container không cần phải trống. Peter Cordes nghĩ rằng điều này có thể vào đặc tả, vì vậy giảm 10 byte cho điều đó.

[](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:;}}

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

Ung dung:

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

-4 byte nhờ 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

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

Giải pháp tương tự như haskell của @ w0lf [answer] [1]

Trường hợp sử dụng hiếm để for-elsexây dựng

Lặp lại thông qua các danh sách được sắp xếp for l in r(trống khi bắt đầu).
Nếu phần tử (từ đầu vào) ilớn hơn phần tử cuối cùng của danh sách l[-1], hãy thêm phần tử vào danh sách l+=[i], ngắt.
Nếu không có danh sách nào được chấp nhận, hãy thêm danh sách mới với elemens nàyr+=[[i]]

R, Công việc đang tiến triển (89, nhưng không thành công)

Giữ một số công việc ở đây, vì tôi đã tự lùi vào một góc bằng cách sử dụng %in%(Nó không thành công với các mục trùng lặp, đặc biệt là trường hợp thử nghiệm cuối cùng) và tôi cần phải làm những việc khác ngay bây giờ, nhưng đây là ở đây nếu có ai muốn xây dựng trên đó:

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

Ung dung:

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 byte

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

Khá đơn giản, chỉ cần lặp lại mảng, tìm mảng bên trong đầu tiên có giá trị cuối cùng <=để giảm giá trị tiếp theo, nếu không tồn tại, nối thêm một mảng bên trong mới với giá trị tiếp theo vào đầu ra, nếu không thì nối giá trị tiếp theo vào đầu tiên tìm thấy mảng bên trong phù hợp với điều kiện.

Cập nhật

Nhờ Neil, lưu ba byte chuyển (...,o)đến ...&&ovà tái tổ chức gọi lại để map()được gọn gàng hơn.

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 byte

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

Kiểm tra nó trực tuyến!

C (gcc) , 176 175 173 byte

#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("");}}

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

Phiên bản có thể đọc được:

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

(Đã chỉnh sửa để thêm 12 ký tự print_r($r);để đáp ứng yêu cầu đầu ra)
(Đã chỉnh sửa để xóa 7 byte khi cho phép Lỗi PHP)
(Đã chỉnh sửa để xóa 11 byte khi đánh bài tập thêm)

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

Cho đầu vào $a, nó tạo ra kết quả$r

Đẹp:

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

Vòng lặp bên ngoài giả định khởi tạo các mảng giữ $bvà loại bỏ $dcác mảng trống, sau đó thực hiện một vòng lặp sắp xếp thả cơ bản, cuối cùng đặt các loại bỏ làm đầu vào mới và thêm các kết quả vào kết quả$r

PHP , 102 byte , 98 byte

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

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

-4 byte, nhờ @Um giác

Giải trình

<?php

Hàm lấy danh sách đầu vào dưới dạng một mảng.

function s($i) {

$s, sẽ trở thành danh sách cuối cùng được trả về danh sách, được khai báo là tĩnh. Điều này mở rộng phạm vi của nó cho tất cả các cuộc gọi của hàm này, cho phép hàm được gọi đệ quy mà không phải chuyển danh sách kết quả này dưới dạng đối số hoặc trả về nó.

    static $s;

Lặp qua từng giá trị trong danh sách.

    foreach ($i as $v)

Là nó ít hơn các thành viên danh sách lớn nhất hiện nay?

        $v < max($l) ?

Có, đưa nó vào danh sách $fđể sắp xếp thêm.

                        $f[] = $v :

Không, đưa nó vào danh sách $l.

                        $l[] = $v;

Đẩy danh sách $lvào danh sách các danh sách.

    $s[] = $l;

Nếu có bất cứ điều gì trong danh sách $f, hãy gửi nó một lần nữa để sắp xếp thêm.

    !$f ?: s($f);

Trả về danh sách các danh sách.

    return $s;
}

Sage, 102 byte

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

Rất giống với câu trả lời của @Dead Possum .
Gắn thêm mỗi thành viên xcủa wdanh sách đầu tiên trong a{danh sách liệt kê} với xlớn hơn yếu tố cuối cùng của nó.
nếu không, nối [x]vào a.

Tôi thực sự muốn nó nếu được existstrả lại anếu không tìm thấy gì! Cũng đang cố gắng áp dụng ý tưởng một dòng của @ Officialaimm ...

Câu hỏi: Nếu tôi xóa mã của mình khỏi hàm, tôi phải gán wcho đầu vào phải không? Vì vậy, nó sẽ tiết kiệm byte?

Ocaml , 69 62 byte

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

Giải trình:

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 byte

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

-0 byte nhờ Kritixi Lithos ...

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

Có một số cách tốt hơn để làm điều này ( Có ). Bất kỳ lời khuyên được đánh giá rất cao và hoan nghênh.

Làm sao?

(Lưu ý, một số giải thích này có thể sai, vì tôi quên cách làm việc này)

{⍵≡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)

Thạch, 26 byte

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

Đây là phương pháp tương tự như câu trả lời APL của marinus.

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

JavaScript (Node.js) , 125 109 106 byte

- 16 18 byte từ Zacharý

-1 bằng cách loại bỏ {và }bằng cách thay đổi bộ tăng để bao gồm "thiết lập cuối cùng cho hiện tại"

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}

Về cơ bản, các câu hỏi là mục hiện tại lớn hơn mục cuối cùng, thêm vào danh sách đầu tiên. Nếu không, thêm vào thứ hai.

Tìm ra trong thời gian này mà so sánh bất kỳ số nào NaNsẽ luôn luôn có kết quả false. Hấp dẫn!

Giải trình:

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

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