[Question]
  [
As described in [this question](https://codegolf.stackexchange.com/questions/61808/lossy-sorting-implement-dropsort?rq=1):
> 
> Dropsort, designed by David Morgan-Mar, is an example of a linear-time "sorting algorithm" that produces a list that is, in fact, sorted, but contains only some of the original elements. Any element that is not at least as large as the maximum of the elements preceding it is simply removed from the list and discarded.
> 
> 
> 
To use one of their test cases, an input of `{1, 2, 5, 4, 3, 7}` yields `{1, 2, 5, 7}`, as `4` and `3` are both dropped for being smaller than the previously "sorted" value, `5`.
We don't want "sorting" algorithms, we want them to be the real deal. Therefore, I want you to write a program that, given a list of numbers, outputs a list of DropSorted lists (to be a complete sorting algorithm, we would need to merge these lists, but 
[merging two sorted lists](https://codegolf.stackexchange.com/questions/25461/merge-two-sorted-lists?rq=1) has been done before, and asking you to do it again is pretty much asking two questions, so this question is specifically the "splitting" step of our complete DropSort).
The arrangement and content of our lists is crucial, however. The output of your program must be equivalent to the output of a DropSort, followed by a DropSort of the discarded values, and so on until you have only have a list of sorted chains. Again, borrowing the existing test suite (and adding two more):
```
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}}
```
You may assume the input is non-empty. 
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so standard rules apply!
  
[Answer]
# Haskell, ~~67 59~~ 58 bytes
```
(q:r)!x|x<last q=q:r!x|1<2=(q++[x]):r
_!x=[[x]]
foldl(!)[]
```
**Explanation:** Given a list of lists (that are already sorted) and a value `x`, the `!` operator will place `x` at the end of the first list whose last element is less than or equal to `x`. If no such list exists, the list `[x]` is placed at the end.
[Try it online.](https://tio.run/##XYu/CsMgHIR3n@KEDkp@Q5P@D/FJRIqQSkNtUk0Gh767NUuHDMfdx8c97fx6eJ@zCG2UPH1T5@28IKjCBeuuUSJUlU5GtpHdeVK6bMOccpPvveBSm/y2wwiFfmLAJw7jgh0cdE1oCCfCkXAgXMxG7wlrbmtt3P90LT/C2eQf)
[Answer]
## [Husk](https://github.com/barbuz/Husk), 10 bytes
```
hUm√º<¬°·π†-√º<
```
[Try it online!](https://tio.run/##yygtzv7/PyM09/Aem0MLH@5coAtk/P//P9pAx0jHVMdEx0DHPBYA "Husk ‚Äì Try It Online")
This is a combination of [my other Husk answer](https://codegolf.stackexchange.com/a/137560/32014) and [xnor's Haskell answer](https://codegolf.stackexchange.com/a/137607/32014).
The duplicate `√º<` feels clunky, but I don't know how to get rid of it...
## Explanation
The function `√º<` translates to `nubBy(>)` in Haskell.
It traverses a list from left to right, keeping those elements for which no previously kept element is strictly greater.
In other words, it performs dropsort.
The leftover elements are obtained by taking list difference of the original list and the result of `√º<`.
```
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]]
```
[Answer]
# [Haskell](https://www.haskell.org/), 50 bytes
```
import Data.List
f[]=[]
f l|r<-nubBy(>)l=r:f(l\\r)
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/PzO3IL@oRMElsSRRzyezuIQrLTrWNjqWK00hp6bIRjevNMmpUsNOM8e2yCpNIycmpkjzf25iZp6CrUJKPpeCQkFRZl6JgopCmkK0oY6CkY6CqY6CiY6CsY6CeSyatIGOAghbgig0ObgmC6A@HQWzWGwmo5EQhlHsfwA "Haskell ‚Äì Try It Online")
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~15~~ ~~10~~ 9 bytes
*5 bytes off using [@beaker](https://codegolf.stackexchange.com/users/42892/beaker)'s idea of cumulative maximum*
```
t"ttY>=&)
```
Input is a numeric row vector, in the format `[1, 2, 5, 4, 3, 7]` (commas are optional). The output contains lists separated by newlines, with the numbers in each list separated by spaces.
[Try it online!](https://tio.run/##y00syfn/v0SppCTSzlZN8///aEMdBSMdBVMdBRMdBWMdBfNYAA) Or [verify all test cases](https://tio.run/##TY07CoBADER7TxEsFCGBzfovtPIIFooI2mu3919nYRWLEOYlj7lPd/nDu9S5dRyywu@5iOTLNPtNmSxTzVQxlUztnmxqmARcLYK0CB0GLy8H7pkAcWsgR0fhK5DVF8TpwwL7WqIKZH71JtQ/).
### Explanation
Given an array, the code picks from it every entry that equals the cumulative maximum up to that entry.
For example, given
```
1 2 5 4 3 7
```
the code picks the first, second, third and sixth entries:
```
1 2 5     7
```
Then the process is repeated on the subarray formed by the remaining entries (in the original order):
```
      4 3
```
This needs to be done until the subarray of remaining entries is empty. An upper bound on the required number of iterations is the input size. The last iterations may not be needed. In that case they operate on an empty array, producing additional empty arrays.
At the end, the stack contains the required arrays and possibly several empty arrays, which are not displayed at all.
```
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
```
[Answer]
## [Husk](https://github.com/barbuz/Husk), 16 bytes
```
hUm‚ÇÅ‚â§¬°‚ÇÅ>
·π†fSz‚Å∞G‚ñ≤
```
[Try it online!](https://tio.run/##yygtzv6vkHtiffGjpsaiQ9v@Z4TmAlmPOpccWgik7bge7lyQFlz1qHGD@6Npm/7//x9tqGOkY6pjomOsYx7LFW1ooKNrqGNoBGTqmuvoWujomupAhIAiljoWOuY6ZjqmEIWGxjqG5jpGhlAeGFkCCSAfYiBYdSwA "Husk ‚Äì Try It Online")
## Explanation
This first line is the main function, and the second is a higher order helper function (it takes a function as argument and returns a new function).
It's accessed by the subscript `‚ÇÅ`.
The idea is that `‚ÇÅ‚â§` performs dropsort and `‚ÇÅ>` gives the leftover elements.
```
·π†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].
```
In the main function, we iterate the leftovers function `‚ÇÅ>` and apply the dropsort function `‚ÇÅ‚â§` to the results.
```
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]]
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~131 112 103~~ 95 bytes
*Thanks a lot @Mr. Xcoder for a smashing 19 bytes!!*
### ***Thanks a lot @ovs for an amazing 17 bytes!***
```
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))
```
[Try it online!](https://tio.run/##RY7BasMwEETv@oo5SskaIqdtEifujyx7MCimOlgOwgX1650NUdKFYWHfzLC3v@VnTvt1DdcRoy2uMxhoU/qCOfNOzlPPg5xDz2IwzhkRMaF0PFEQjpeJGy@y7SMZ5OvymxNPsrUFQwo2fLO4zWiDc@sry@wJLeGT8EHYEw5CeIxhvyM0Sn1bT6igOSg4qjT08qjF8ImgZ6VfWvgfelZ5LffKWv8mFVSdHuvJDL//qYUi3S3HtNjRRueA9Q4 "Python 3 ‚Äì Try It Online")
## Explanation:
```
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
```
[Answer]
# [Haskell](https://www.haskell.org/), ~~113~~ ~~107~~ ~~102~~ 92 bytes
```
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=[]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/PzO3IL@oRMElsSRRzyezuIQrUVEjySpZsybJJiexuEQh0TZRMbnG0M7ANlFbOzopVjEZqCLJNpErXaHCAaIy00YXLGGbaZWuURETk6kJkrSNjv2fm5iZZ1tQlJlXopIebahjBISGOsY6JjpGsf8B "Haskell ‚Äì Try It Online")
This feels *really* long.
# Explanation
`!` performs the drop sort on a list, while `#` collects the trimmings. `g` then repeatedly applies `#` until the list is empty recording the results in a list.
[Answer]
# APL, 27 bytes
```
{‚çµ‚â°‚ç¨:‚ç¨‚ãÑ(‚äÇX/‚çµ),‚àá‚çµ/‚ç®~X‚Üê‚çµ‚â•‚åà\‚çµ}
```
Explanation:
* `‚çµ‚â°‚ç¨:‚ç¨`: if the input is empty, return the empty list
* `X‚Üê‚çµ‚â•‚åà\‚çµ`: all numbers greater or equal to the running maximum
* `(‚äÇX/‚çµ)`: the list of those numbers,
* `‚àá‚çµ/‚ç®~X`: followed by the result of running this function on the remaining numbers
[Answer]
# JavaScript (ES6), 64 bytes
```
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]
```
[Answer]
# [R](https://www.r-project.org/), 61 bytes
```
f=function(x)if(sum(x|1)){print(x[b<-x==cummax(x)]);f(x[!b])}
```
[Try it online!](https://tio.run/##K/r/P802rTQvuSQzP0@jQjMzTaO4NFejosZQU7O6oCgzr0SjIjrJRrfC1ja5NDc3sQKoJlbTOg0oqpgUq1n7P00jWcPQQAeCLIGEpiYXWExHwUhHwVRHwURHwVhHwVxT8z8A "R ‚Äì Try It Online")
Recursive function. `sum(x|1)` is shorthand for `length(x)`, so this recursion will run untill `x` is empty. `cummax` takes the cumulative maximum of `x`, which is then compared to `x` again. This produces a boolean vector of length `x`, where all the TRUEs correspond to sorted values. We use that to take a subset of `x` and `print` it. The function is then called again on the remainder of `x`.
[Answer]
# Java 8, ~~182~~ ~~179~~ 177 bytes
```
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 bytes thanks to *@Nevay*.  
-2 bytes by using `Stack` instead of `Vector`.
**Explanation:**
[Try it here.](https://tio.run/##rZJfb8IgFMXf/RT3ESbF1v1xBmuyxyWbWeLjsgdW0aBIG3rrdMbP7m61LiZ7XJvQlgvnx@HAUm90lBfGL2ero10XeUBYUk1WaJ28UQDQ68GbpnI@h88dmijLK4@dzOmyhFdt/b4DYD2aMNeZgUndBXixJULGnkLQu/p/9EwzFiaMwXFFMw4depWo0WYwAQ8pHF003p9kIfXmC6aosxXjAtU8D4wWgEJYsVVOlvbbMD6OFa9HitTJhUEWcxGkns0YXsu5sGms7OiiUkW65XbO2LaR2W6X83FacDyJnQxmnW8MiyLLuQoGq@AhqMNR1Y6L6tOR48b4JrczWFMEbIrB@sX7B2h@3v90V6JZy7xCWdAQOs@8zFjt7G8m55hKqcu6zBIBfQH3Au4E3AoYcHrU/6mxgIjQSb8dXjQg3iM1MnpBt0MeCiAu4R8ohfY2n1CWCVH7SYvMpg3rTzvY33NvMmiHGl/dqfjqTh06h@MP)
```
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
```
[Answer]
# C#, ~~188~~ 203 bytes
```
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();}
```
The byte count includes +18 for:
```
using System.Linq;
```
[Try it online!](https://tio.run/##hZPda8IwEMDf/SuOPkjCYrHuw4lWEN@Gg6EDH8SHUE8N2HRLMofU/u3u/KhanHo0XJv73fUud4lsJU50stEyRvslI4TByjqM/Z7S36W0BCTRQloLH7v3/c5WrJNORbBM1ATepdKMH00naCtKu9F4NAaH1nWlRQthwV6kt6Lxl/gUAgE1Ac8CngQ8CqhDJq6zVQEVcghqt6hKnahXWhQ0d7jFNwQQTU4vlMe93weUY0BsLbhLHlZjq27Bx9oPWdxiq2enVf3ntLJmqfA9TQzKaA5s16Bje6hfp1bxO53qJtomC/SHRjmkkUHmpR480HAYpWf@W0Jz4QmgZ8ryoNwf4AIjxySEbbjGS07bXubxXDeLxRRryfPoo5zs0jjDz9D9zG4OEzndVy55utMulP5wjgYZ00LxsK1awXqt26EcqUow5v5n0jFGrhgX8QXarpbLunVBNpfSgA2pRfk1SF1G5p6yjqxqymK/ownk1u9MJn2pZ8hok/OmQfdjNNizYNlmX0@2@QM "C# (Mono) ‚Äì Try It Online")
[Answer]
# C++14, ~~118~~ 108 bytes
Using the algorithm from [w0lf's Haskell answer](https://codegolf.stackexchange.com/a/137563/53667).
As unnamed generic lambda. First parameter is a container of the values to dropsort (like `vector<int>`) and second parameter requires a compatible empty container of containers (like `vector<vector<int>>`) for the return value via reference.
In the first version of the program, there was `R.clear;()` as first statement, so that the container of containers didnt need to be empty.
Peter Cordes thought this could into the specification, so dropping 10 byte for that.
```
[](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:;}}
```
[Try it online!](https://tio.run/##TZDbasMwDIbv9RSigxKDl7Q7U6eBQugDhN2NMTzHabPlRGyPQPCzZ07Sht5Y1qdf/mWJprk/CTHc5ZUoTCrDvFa6lbyMYEF/Uui6jQCMyqsTVryUquFCotIpA@BG15jth49Pb7yuD3QKCekTXxSStx5hWd1ORex2B9Jfs3W8S0ieebH/zcWvR8KO9LHfGHX@mkBH2Kl2TUdmE1@WTeFM58qWutpxx6wd3AR5pbHkeeWRHuZhQ4cifJdKC64k7hGCAPstxQeKzxSfKD5SfLUzXsCbYxRfHMZ@c6PdTFoEZ3V5/sYlwkQqU2gGc7yZ/@pPXGO2ZHTWEYZB8GOURvdDLcd4lnhZmNPXLS5Lmht6wIW6RcYjQFEbjWGI3XisKK4YoIUFyyotGFgAO/wD "C++ (gcc) ‚Äì Try It Online")
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:;
 }
}
```
[Answer]
# [Python 2](https://docs.python.org/2/), 88 bytes
-4 bytes thanks to 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
```
[Try it online!](https://tio.run/##TY3NCsIwEITP5imWnhS30NSf2mieJORga0qDIS2xoj593EArHoZlvt3ZGT9TP/gytsPNyCzLYoNBWj8@p/UGlWbdEMCC9dAIBsm4ZIJgK9uBUznXF2mF20pl9bkJ5npnYNzDiECImGZjsH6CEOk5e/XWGeDCvE0LqTIqjlAiHBD2CDuESjPFC4ScOC/J5BWZE4lOFk64RiBIuyOF5wynPCdU8gXMqtMg9muZo4SKv/oi1X8B "Python 2 ‚Äì Try It Online")
Solution similar to @w0lf's haskell [answer][1]
Rare use case for `for-else` construction
Iterate through sorted lists `for l in r` (empty at start).  
If element(from input) `i` is larger than last element of list `l[-1]`, add element to list `l+=[i]`, break.  
If no list was accepted, add new list with this elemens `r+=[[i]]`
[Answer]
# JavaScript (ES6), ~~71~~ ~~70~~ 68 bytes
```
a=>a.map(n=>(o.find(b=>[...b].pop()<=n)||(n=[n],o)).push(n),o=[])&&o
```
Pretty simple, just iterates the array, looks for the first inner array whose last value is `<=` to the next value to drop, if none exists, append a new inner array with the next value to the output, otherwise append the next value to the first found inner array that matches the condition.
### Updates
Thanks to Neil, saved three bytes converting `(...,o)` to `...&&o` and re-organizing the callback to `map()` to be more compact.
```
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}
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 29 bytes
```
@lOpP)<1}a@=f_<V¬™OoV=Z+S}V=Ug
```
[Test it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=QGxPcFApPDF9YUA9Zl88VqpPb1Y9WitTfVY9VWc=&input=WzUsIDQsIDMsIDgsIDcsIDZd)
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 176 175 173 bytes
```
#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("");}}
```
[Try it online!](https://tio.run/##JY7LCsIwFET3fkWNCLmmQnVXb6O/0H3IIvShCTGWNpJA6bfX2sIwm3MGpjo/q2qeD3XTatckJY3Q9dr5lpJjnZDU8wi4s@IqRZ5L9BhRo8GAb6UdVTCGl7YNHSrl1glJT5YFuGfAWMANah5gLKkViu@VFIFnEtpPTw2/oCk0MmZgjHzhUhiJsfAPK1aTMcnj7X9q6r5@oIQATtM8X7JkS77UDw "C (gcc) ‚Äì Try It Online")
Somewhat readable version:
```
#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("");
    }
}
```
[Answer]
# PHP, ~~91~~ ~~103~~ ~~96~~ 85 bytes
(Edited to add 12 chars of `print_r($r);` to meet requirement to output)  
(Edited to remove 7 bytes when allowing PHP Errors)  
(Edited to remove 11 bytes when golfing the assignment further)
```
while($a){$b=$d=[];foreach($a as$i)${max($b)>$i?d:b}[]=$i;$a=$d;$r[]=$b;}print_r($r);
```
Given input `$a`, it produces result `$r`
Pretty:
```
while ($a) {
    $b = $d = [];
    foreach ($a as $i) {
        ${max($b) > $i ? d : b}[] = $i;
    }
    $a   = $d;
    $r[] = $b;
}
```
The pseudo-recursive outer loop initializes the keep `$b` and discard `$d` arrays to empty, then does a basic drop sort loop, finally setting the discards as the new input and adding the keeps to the result `$r`
[Answer]
# [PHP](https://php.net/), ~~102 bytes~~, 98 bytes
```
<?php function s($i){static$s;foreach($i as$v)${$v<max($l)?f:l}[]=$v;$s[]=$l;!$f?:s($f);return$s;}
```
[Try it online!](https://tio.run/##NYxNCoMwEEb3nmIKs0ggm/5RMIoX6A1ESggGAzaGzCgF8expuujqwcf7Xpxizk0XpwhuDZb9EoAEerkTG/YWSbsljcZOZQRDuEnccWve5iNwlp2r56MfWtw00o@zPqHr6pJwUqeR1xRK4sjII/HTE0ML/VnBRcFdwU3BVcFj0FUVkw/8SqI8/6qUOn8B "PHP ‚Äì Try It Online")
*-4 bytes, thanks to @Umbrella*
**Explanation**
```
<?php
```
The function takes the input list as an array.
```
function s($i) {
```
`$s`, which will become the finally returned list of lists, is declared static. This 
extends its scope to *all* calls of this function, allowing the function to be called 
recursively without having to pass this result list as an argument or to return it.
```
    static $s;
```
Loop through each value in the list.
```
    foreach ($i as $v)
```
Is it less than the biggest current list member?
```
        $v < max($l) ?
```
Yes, put it on list `$f` for further sorting.
```
                        $f[] = $v :
```
No, put it on list `$l`.
```
                        $l[] = $v;
```
Push list `$l` onto the list of lists.
```
    $s[] = $l;
```
If there's anything in list `$f`, send it round again for further sorting.
```
    !$f ?: s($f);
```
Return the list of lists.
```
    return $s;
}
```
[Answer]
## Sage, 102 bytes
```
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
```
Very similar to @Dead Possum's [answer](https://codegolf.stackexchange.com/a/137573/137573).  
Appends each member `x` of `w` to the first list in `a` {list of lists} with `x` greater than it's last element.  
if none, appends `[x]` to `a`. 
I would really like it if `exists` returned `a` if nothing was found! Also trying to apply @officialaimm's [one-line](https://codegolf.stackexchange.com/a/137553/137553) idea ...
Question: If I removed my code from the function, I'd have to assign `w` to input right? So would it save bytes?
[Answer]
# [Ocaml](https://ocaml.org), ~~69~~ 62 bytes
```
let rec d=function h::i::t when h>i->d(h::t)|h::t->h::d t|x->x
```
Explanation:
```
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
```
[Answer]
# APL, ~~100~~ ~~88~~ ~~83~~ ~~79~~ ~~78~~ ~~57~~ ~~56~~ ~~77~~ 76 bytes
```
{(E/‚çµ),‚äÇ‚çµ/‚ç®~E‚Üê(‚ç¨‚â¢‚ç¥)¬®‚çµ}‚àò{‚çµ‚â°(S‚Üê¬Ø1‚Üì‚çµ),‚äÉ‚äÉ‚åΩ‚çµ:‚çµ‚ãÑ‚àáS,‚äÉ‚åΩ‚çµ}{‚çµ‚â°X‚Üê‚çµ/‚ç®~V‚Üê‚çµ‚â†‚åà\‚çµ:‚çµ‚ãÑX(‚àáV/‚çµ)}
```
-0 bytes thanks to Kritixi Lithos...
[Try it online!](http://tryapl.org/?a=%28%7B%28E/%u2375%29%2C%u2282%u2375/%u2368%7EE%u2190%28%u236C%u2262%u2374%29%A8%u2375%7D%u2218%7B%u2375%u2261%28S%u2190%AF1%u2193%u2375%29%2C%u2283%u2283%u233D%u2375%3A%u2375%u22C4%u2207S%2C%u2283%u233D%u2375%7D%7B%u2375%u2261X%u2190%u2375/%u2368%7EV%u2190%u2375%u2260%u2308%5C%u2375%3A%u2375%u22C4X%28%u2207V/%u2375%29%7D%29%2810%20%AF1%2012%200%201%29&run)
There's got to be some better way to do this ([There is](https://codegolf.stackexchange.com/a/137919/55550)). Any tips are very greatly appreciated and welcome.
## How?
(Note, some of this explanation might be wrong, as I forgot how this worked)
```
{‚çµ‚â°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)
```
[Answer]
# Jelly, 26 bytes
```
<¬ª\¬¨x@√∞W;¬µ‚Å∏√ë
<¬ª\x@¬µ√ë
1ƒø¬πL?
```
This is the same method as marinus' APL answer.
[Try it online!](https://tio.run/##y0rNyan8/9/m0O6YQ2sqHA5vCLc@tPVR447DE7lAYhUOh7YCmYZH9h/a6WP//3C7@///0YY6CkY6CqY6CiY6CsY6CuaxAA).
[Answer]
# JavaScript [(Node.js)](https://nodejs.org), ~~125~~ ~~109~~ 106 bytes
-~~16~~ 18 bytes from Zachar√Ω
-1 by removing `{` and `}` by changing the incrementer to include the "set last to the 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}
```
Basically, asks is the current item greater than the last item, add to the first list. Otherwise, add to the second.
Found out during this that comparing any number to `NaN` will always result `false`. Interesting!
Explanation:
```
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
```
[Try it online!](https://tio.run/##dY9NDoIwEIX3nmKWJRbS4i@p9QheoOmCaJWaSgmgIRjPjqNBowabTNqZ92Ve3zG9pNW2tEUd5n5nuu4kG7m@tlIpTZXWwslNuhF7XxIrmbCrJnImP9QZCo2y47EO7J64Nb510Cquo@JcZeTZCuMqA61iX8PS1Ocyh/bWbX1eeWci5w/kRBSnEFOYUZhSmFBY6CAQo1@GUQgR5PGQGi5QXWLhkhc4xCUUkEJ4jn7/bDj@gSMT879EX8njGoLeWXq3IYZ9pGav1F1/7g)
]