如这个问题所述：

由David Morgan-Mar设计的Dropsort是线性时间“排序算法”的一个示例，该算法可以生成一个列表，该列表实际上是经过排序的，但仅包含一些原始元素。任何不小于其最大元素数量的元素都将从列表中删除并丢弃。

要使用他们的测试用例之一，请输入{1, 2, 5, 4, 3, 7}yields {1, 2, 5, 7}as 4和as ，3因为它们小于先前的“ sorted”值5。

我们不想“排序”算法，我们希望它们成为真正的交易。因此，我希望您编写一个程序，给定一个数字列表，该程序输出一个DropSorted列表列表（作为完整的排序算法，我们需要合并这些列表，但是 之前已经完成了合并两个排序列表的操作，并且要求您再次执行此操作几乎是在问两个问题，因此，这个问题专门是我们完整的DropSort的“拆分”步骤。

但是，清单的安排和内容至关重要。程序的输出必须等同于DropSort的输出，然后是丢弃值的DropSort的输出，依此类推，直到只有一个排序链列表为止。同样，借用现有的测试套件（并添加另外两个）：

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字节

使用@beaker的累积最大值的概念减少5个字节

t"ttY>=&)

输入是数字行向量，格式为[1, 2, 5, 4, 3, 7]（逗号为可选）。输出包含用换行符分隔的列表，每个列表中的数字用空格分隔。

在线尝试！或验证所有测试用例。

说明

给定一个数组，代码从中选择每个条目，该条目等于该条目的累积最大值。

例如，给定

1 2 5 4 3 7

该代码选择第一，第二，第三和第六项：

1 2 5     7

然后，对其余条目形成的子数组重复该过程（按原始顺序）：

      4 3

这需要完成，直到剩余条目的子数组为空。所需迭代次数的上限是输入大小。可能不需要最后的迭代。在这种情况下，它们将在空数组上运行，从而产生其他空数组。

最后，堆栈包含所需的数组，可能还包含几个空数组，这些数组根本不会显示。

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]放在最后。

在线尝试。

外壳，10个字节

hUmü<¡Ṡ-ü<

在线尝试！

这是我的其他Husk答案和xnor的Haskell答案的组合。复制品ü<感觉笨拙，但我不知道如何摆脱它...

说明

该函数ü<翻译为nubBy(>)Haskell。它从左到右遍历一个列表，保留以前严格保留的元素没有更大的那些元素。换句话说，它执行dropsort。剩余元素通过获取原始列表的列表差异和的结果获得ü<。

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)

在线尝试！

外壳，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].

在main函数中，我们迭代剩余函数₁>并将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字节

非常感谢@先生。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)]

取消高尔夫：

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)，因此此递归将一直运行，直到l x为空。cummax取的累积最大值x，然后将其与x再次比较。这将生成一个布尔向量length x，其中所有TRUE都对应于排序后的值。我们用它作为xand 的子集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个字节Stack代替Vector。

说明：

在这里尝试。

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＃，188203字节

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， 14、118 108个字节

使用w0lf的Haskell答案中的算法。

作为未命名的通用lambda。第一个参数是要进行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:;}}

在线尝试！

取消高尔夫：

[](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的haskell类似的解决方案[answer] [1]

稀有for-else建筑用例

遍历已排序的列表for l in r（开始时为空）。
如果element（来自输入）i大于list的最后一个元素l[-1]，则将元素添加到list l+=[i]，然后中断。
如果未接受任何列表，请使用此元素添加新列表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}}

取消高尔夫：

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

非常简单，只需迭代数组，然后查找第一个内部数组，该数组的最后一个值将是<=要删除的下一个值，如果不存在，则将带有下一个值的新内部数组附加到输出，否则将下一个值附加到第一个数组找到符合条件的内部数组。

更新

感谢Neil，节省了三个字节，(...,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);以满足输出要求）
（编辑以允许PHP错误时删除7个字节）
（编辑以进一步查看分配时删除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;
}

伪递归外部循环将keep $b和throws $d数组初始化为空，然后执行一个基本的drop sort循环，最后将Displaces设置为新输入，并将keeps添加到结果中$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;
}

贤者，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{列出的名单}与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?

这与marinus的APL答案相同。

在线尝试！。

的JavaScript （Node.js的），125个 109 106字节

- 来自Zacharý的16 18字节

-1，方法是删除{并}更改增量器以包括“最后设置为当前”

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

在线尝试！