Como se describe en esta pregunta :

Dropsort, diseñado por David Morgan-Mar, es un ejemplo de un "algoritmo de clasificación" de tiempo lineal que produce una lista que, de hecho, está ordenada, pero contiene solo algunos de los elementos originales. Cualquier elemento que no sea al menos tan grande como el máximo de los elementos que lo preceden simplemente se elimina de la lista y se descarta.

Para utilizar una de sus casos de prueba, una entrada de {1, 2, 5, 4, 3, 7}rendimientos {1, 2, 5, 7}, como 4y 3están ambos cayó por ser más pequeño que el previamente "ordenados" valor, 5.

No queremos algoritmos de "clasificación", queremos que sean el verdadero negocio. Por lo tanto, quiero que escriba un programa que, dada una lista de números, genere una lista de listas DropSorted (para ser un algoritmo de ordenación completo, necesitaríamos fusionar estas listas, pero antes se había fusionado dos listas ordenadas , y pedirle que lo vuelva a hacer es más o menos dos preguntas, por lo que esta pregunta es específicamente el paso de "división" de nuestro DropSort completo).

Sin embargo, la disposición y el contenido de nuestras listas es crucial. La salida de su programa debe ser equivalente a la salida de un DropSort, seguido de un DropSort de los valores descartados, y así sucesivamente hasta que solo tenga una lista de cadenas ordenadas. Nuevamente, tomando prestado el conjunto de pruebas existente (y agregando dos más):

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

Puede suponer que la entrada no está vacía.

Este es el código de golf , por lo que se aplican reglas estándar.

MATL , 15 10 9 bytes

5 bytes de descuento utilizando la idea de @beaker del máximo acumulado

t"ttY>=&)

La entrada es un vector de fila numérico, en el formato [1, 2, 5, 4, 3, 7](las comas son opcionales). La salida contiene listas separadas por nuevas líneas, con los números en cada lista separados por espacios.

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

Dada una matriz, el código selecciona de cada entrada que iguala el máximo acumulado hasta esa entrada.

Por ejemplo, dado

1 2 5 4 3 7

El código selecciona las entradas primera, segunda, tercera y sexta:

1 2 5     7

Luego, el proceso se repite en el subconjunto formado por las entradas restantes (en el orden original):

      4 3

Esto debe hacerse hasta que el subconjunto de entradas restantes esté vacío. Un límite superior en el número requerido de iteraciones es el tamaño de entrada. Las últimas iteraciones pueden no ser necesarias. En ese caso, operan en una matriz vacía, produciendo matrices vacías adicionales.

Al final, la pila contiene las matrices requeridas y posiblemente varias matrices vacías, que no se muestran en absoluto.

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 bytes

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

Explicación: Dada una lista de listas (que ya están ordenadas) y un valor x, el !operador colocará xal final de la primera lista cuyo último elemento es menor o igual que x. Si no existe dicha lista, la lista [x]se coloca al final.

Pruébalo en línea.

Casco , 10 bytes

hUmü<¡Ṡ-ü<

Pruébalo en línea!

Esta es una combinación de mi otra respuesta de Husk y la respuesta de Haskell de xnor . El duplicado se ü<siente torpe, pero no sé cómo deshacerme de él ...

Explicación

La función se ü<traduce en nubBy(>)en Haskell. Atraviesa una lista de izquierda a derecha, manteniendo aquellos elementos para los cuales ningún elemento previamente guardado es estrictamente mayor. En otras palabras, realiza dropsort. Los elementos sobrantes se obtienen tomando la diferencia de lista de la lista original y el resultado de ü<.

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 bytes

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

Pruébalo en línea!

Casco , 16 bytes

hUm₁≤¡₁>
ṠfSz⁰G▲

Pruébalo en línea!

Explicación

Esta primera línea es la función principal, y la segunda es una función auxiliar de orden superior (toma una función como argumento y devuelve una nueva función). Se accede por el subíndice ₁. La idea es que ₁≤realiza dropsort y ₁>da los elementos sobrantes.

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

En la función principal, iteramos la función sobrante ₁>y aplicamos la función dropsort ₁≤a los resultados.

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 bytes

Muchas gracias, señor. ¡Xcoder para un espectacular 19 bytes!

¡Muchas gracias @ovs por los increíbles 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))

Pruébalo en línea!

Explicación:

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

Pruébalo en línea!

Esto se siente muy largo.

Explicación

!realiza la ordenación por caída en una lista, mientras #recopila los recortes. gluego se aplica repetidamente #hasta que la lista esté vacía registrando los resultados en una lista.

APL, 27 bytes

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

Explicación:

• ⍵≡⍬:⍬: si la entrada está vacía, devuelve la lista vacía
• X←⍵≥⌈\⍵: todos los números mayores o iguales al máximo de ejecución
• (⊂X/⍵): la lista de esos números,
• ∇⍵/⍨~X: seguido del resultado de ejecutar esta función en los números restantes

JavaScript (ES6), 64 bytes

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

Sin golf:

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 bytes

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

Pruébalo en línea!

Función recursiva. sum(x|1)es la abreviatura de length(x), por lo que esta recursión se ejecutará hasta que xesté vacía. cummaxtoma el máximo acumulado de x, que luego se compara con xotra vez. Esto produce un vector booleano de longitud x, donde todas las VERDADERAS corresponden a valores ordenados. Usamos eso para tomar un subconjunto xy print. La función se llama nuevamente en el resto de x.

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 gracias a @Nevay .
-2 bytes usando en Stacklugar de Vector.

Explicación:

Pruébalo aquí

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

El recuento de bytes incluye +18 para:

using System.Linq;

Pruébalo en línea!

C ++ 14, 118108 bytes

Usando el algoritmo de la respuesta de Haskell de w0lf .

Como lambda genérico sin nombre. El primer parámetro es un contenedor de los valores a dropsort (like vector<int>) y el segundo parámetro requiere un contenedor de contenedores vacío compatible (like vector<vector<int>>) para el valor de retorno por referencia.

En la primera versión del programa, había una R.clear;()primera declaración, por lo que el contenedor de contenedores no necesitaba estar vacío. Peter Cordes pensó que esto podría entrar en la especificación, por lo que soltó 10 bytes para eso.

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

Pruébalo en línea!

Sin golf:

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

-4 bytes gracias a 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

Pruébalo en línea!

Solución similar a haskell de @ w0lf [respuesta] [1]

Caso de uso raro para for-elseconstrucción

Iterar a través de listas ordenadas for l in r(vacías al inicio).
Si el elemento (de la entrada) ies más grande que el último elemento de la lista l[-1], agregue el elemento a la lista l+=[i], interrumpa.
Si no se aceptó ninguna lista, agregue una nueva lista con este elementor+=[[i]]

R, trabajo en progreso (89, pero falla)

Manteniendo algo de trabajo aquí, porque me arrinconé en una esquina usando %in%(falla en entradas duplicadas, en particular el último caso de prueba), y necesito hacer otras cosas ahora, pero esto es aquí si alguien quiere construir sobre él:

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

Sin golf:

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 bytes

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

Bastante simple, solo itera la matriz, busca la primera matriz interna cuyo último valor es <=el siguiente valor a soltar, si no existe ninguno, agregue una nueva matriz interna con el siguiente valor a la salida, de lo contrario agregue el siguiente valor al primero encontrado matriz interna que coincide con la condición.

Actualizaciones

Gracias a Neil, guardan tres bytes convertir (...,o)a ...&&oy la reorganización de la devolución de llamada a map()ser más compacto.

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 bytes

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

¡Pruébelo en línea!

C (gcc) , 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("");}}

Pruébalo en línea!

Versión algo legible:

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

(Editado para agregar 12 caracteres print_r($r);para cumplir con el requisito de salida)
(Editado para eliminar 7 bytes cuando se permiten errores de PHP)
(Editado para eliminar 11 bytes cuando se sigue jugando la tarea)

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

Dada entrada $a, produce resultado$r

Bonita:

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

El bucle externo pseudo-recursivo inicializa las matrices keep $by descarte $dpara vaciarlas, luego realiza un bucle básico de clasificación por caída, finalmente establece los descartes como la nueva entrada y agrega las conservas al resultado$r

PHP , 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;}

Pruébalo en línea!

-4 bytes, gracias a @Umbrella

Explicación

<?php

La función toma la lista de entrada como una matriz.

function s($i) {

$s, que se convertirá en la lista de listas finalmente devuelta, se declara estática. Esto amplía su alcance a todas las llamadas de esta función, permitiendo que la función se llame de forma recursiva sin tener que pasar esta lista de resultados como argumento o devolverla.

    static $s;

Recorre cada valor de la lista.

    foreach ($i as $v)

¿Es menos que el miembro más grande de la lista actual?

        $v < max($l) ?

Sí, póngalo en la lista $fpara su posterior clasificación.

                        $f[] = $v :

No, ponlo en la lista $l.

                        $l[] = $v;

Empuje la lista $la la lista de listas.

    $s[] = $l;

Si hay algo en la lista $f, envíelo nuevamente para ordenarlo más.

    !$f ?: s($f);

Devuelve la lista de listas.

    return $s;
}

Sabio, 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

Muy similar a la respuesta de @Dead Possum .
Agrega a cada miembro xde wla primera lista en a{lista de listas} con xmayor que su último elemento.
si ninguno, se agrega [x]a a.

¡Realmente me gustaría que fuera existsdevuelto asi no se encuentra nada! También tratando de aplicar la idea de una línea de @ officialaimm ...

Pregunta: Si eliminé mi código de la función, ¿tendría que asignar la wentrada correcta? Entonces, ¿ahorraría bytes?

Ocaml , 69 62 bytes

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

Explicación:

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 bytes

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

-0 bytes gracias a Kritixi Lithos ...

Pruébalo en línea!

Tiene que haber una mejor manera de hacer esto ( Hay ). Cualquier consejo es muy apreciado y bienvenido.

¿Cómo?

(Tenga en cuenta que parte de esta explicación podría estar equivocada, ya que olvidé cómo funcionaba)

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

Jalea, 26 bytes

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

Este es el mismo método que la respuesta APL de marinus.

Pruébalo en línea! .

JavaScript (Node.js) , 125 109 106 bytes

- 16 18 bytes de Zacharý

-1 quitando {y }cambiando el incrementador para incluir el "conjunto último al actual"

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}

Básicamente, pregunta es el elemento actual mayor que el último elemento, agregar a la primera lista. De lo contrario, agregue a la segunda.

Descubrí durante esto que NaNsiempre resultará comparar cualquier número false. ¡Interesante!

Explicación:

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

Pruébalo en línea!