この質問で説明されているように：

David Morgan-Marによって設計されたDropsortは、実際にはソートされているが、元の要素の一部のみを含むリストを生成する線形時間「ソートアルゴリズム」の例です。少なくともその前の要素の最大値よりも大きくない要素は、単にリストから削除されて破棄されます。

テストケースの1つを使用するに{1, 2, 5, 4, 3, 7}は{1, 2, 5, 7}、yieldsの入力としてas 4およびasの3両方が、以前に「ソートされた」値より小さいためにドロップされます5。

「ソート」アルゴリズムが必要なわけではありません。それが本物であることを望んでいます。したがって、数値のリストを指定して、DropSortedリストのリストを出力するプログラムを作成してください（完全なソートアルゴリズムであるために、これらのリストをマージする必要がありますが、 2つのソートされたリストのマージは以前に行われ、もう一度行うように依頼することは、2つの質問をすることとほぼ同じです。したがって、この質問は、具体的には完全なDropSortの「分割」ステップです。

ただし、リストの配置と内容は非常に重要です。プログラムの出力は、DropSortの出力と同等であり、その後に破棄された値のDropSortが続き、ソートされたチェーンのリストのみになるまで続きます。繰り返しますが、既存のテストスイートを借用します（さらに2つ追加します）。

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

入力が空でないと仮定できます。

これはcode-golfなので、標準のルールが適用されます！

MATL、15 10 9バイト

累積最大値の@beakerのアイデアを使用して5バイトオフ

t"ttY>=&)

入力は、形式の数値行ベクトルです[1, 2, 5, 4, 3, 7]（コンマはオプションです）。出力には、改行で区切られたリストが含まれ、各リストの数字はスペースで区切られています。

オンラインでお試しください！または、すべてのテストケースを確認します。

説明

配列を指定すると、コードはそのエントリまでの累積最大値に等しいすべてのエントリをそこから選択します。

たとえば、与えられた

1 2 5 4 3 7

コードは、1番目、2番目、3番目、6番目のエントリを選択します。

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の回答の組み合わせです。複製ü<は不格好に感じますが、それを取り除く方法がわかりません...

説明

この関数はHaskellにü<変換さnubBy(>)れます。リストを左から右に走査し、以前に保持された要素が厳密に大きくない要素を保持します。つまり、ドロップソートを実行します。残りの要素は、元のリストとの結果のリストの差分を取ることにより取得されü<ます。

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▲

オンラインでお試しください！

説明

この最初の行はメイン関数であり、2番目は高次ヘルパー関数です（関数を引数として受け取り、新しい関数を返します）。subscriptによってアクセスされます₁。アイデアは、₁≤ドロップソートを実行し₁>、残りの要素を提供することです。

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

メイン関数では₁>、leftovers関数を繰り返し、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。に感謝します。破壊的な19バイトのXcoder !!

驚くべき17バイトをありがとう@ovs！

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

ハスケル、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)、この再帰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;}

@Nevayのおかげで-3バイト。
-のStack代わりにを使用して-2バイト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、118の 108バイト

w0lfのHaskell answerのアルゴリズムを使用します。

名前のない汎用ラムダとして。最初のパラメーターはドロップソートする値のコンテナー（などvector<int>）であり、2番目のパラメーターは、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バイト

Arnold Palmerのおかげで-4バイト

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に似たソリューション[回答] [1]

for-else建設のためのまれなユースケース

ソートされたリストを反復処理しますfor l in r（開始時に空）。
element（from from）iがlistの最後の要素より大きい場合l[-1]、list l+=[i]にbreak 要素を追加します。
リストが受け入れられなかった場合、この要素を含む新しいリストを追加します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)ために3バイト節約されました。...&&omap()

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バイト

（print_r($r);出力の要件を満たすために12文字を追加
するように
編集されました）（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およびdiscard $d配列を初期化して空にした後、基本的なドロップソートループを実行し、最後に廃棄を新しい入力として設定し、結果にkeep を追加します$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;

list $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の1行のアイデアを適用しようとしています...

質問：関数からコードを削除した場合、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回答と同じ方法です。

オンラインでお試しください！。

JavaScriptの（Node.jsの）、125の 109 106バイト

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

基本的に、asksは最後のアイテムよりも大きい現在のアイテムで、最初のリストに追加します。それ以外の場合は、2番目に追加します。

この間、任意の数値を比較する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

オンラインでお試しください！