Clasifíquelo como si estuviera caliente

41

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 , por lo que se aplican reglas estándar.

Lord Farquaad
fuente
¿Podemos sacar como [5, 4, 3, 8, 7, 6] -> [5, 8], [4,3,7,6]?
Sr. Xcoder
55
@Xcoder, bueno, no me importa la sintaxis, pero aún tiene que ordenar la segunda lista (y dividirla en este caso). Saber cuándo parar es parte del desafío;). Y Stewie, realmente no sé qué decirte. Vi el desafío de DropSort y pensé que esto sonaba divertido. ¿Alguna posibilidad de que haya usado su máquina del tiempo para avanzar y ver esta pregunta? ¡Simplemente no lo use para ver la mejor respuesta!
Lord Farquaad
Tenga en cuenta que agregar la clasificación de los sobrantes elimina las soluciones del tiempo lineal.
ikegami
Debería {3,4,5,3,4,5,3,4,5}resultar en {{3,4,5,5,5},{3,4,4},{3}}?
QBrute
@ QBrute Creo que es correcto.
Lord Farquaad

Respuestas:

10

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
Luis Mendo
fuente
23

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.

Cristian Lupascu
fuente
3
Esta es una solución increíblemente inteligente. Sinceramente, esperaba que la mayoría de las personas simplemente dejaran caer DropSort una y otra vez hasta que no quedara nada, pero esperaba que alguien pensara en una forma más creativa.
Lord Farquaad
13

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]]
Zgarb
fuente
10
Supera la respuesta superior en un 33% "No sé, se siente torpe"
Lord Farquaad
11

Haskell , 50 bytes

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

Pruébalo en línea!

xnor
fuente
1
Casi tuve esto, simplemente no sabía la \\ función: (
H.PWiz
2
¡Oh, esa sí que es una función muy útil! Solución muy agradable =)
flawr
7

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]]
Zgarb
fuente
Husk is the new Jelly ...
Erik the Outgolfer
1
@EriktheOutgolfer Golpeado por MATL. : /
Zgarb
6

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
officialaimm
fuente
2
116 bytes. El if-elsese puede colapsar en [m,d][i<m[-1]]+=[i].
Sr. Xcoder
Woah, Muchas gracias ... yo estaba tryng que [m,d]cosa, pero no estaba funcionando de alguna manera ....
officialaimm
1
113 bytes . (len(d)>0)es bool(d)porque las listas vacías son falsas en Python. +1, ¡Buena solución!
Sr. Xcoder
1
95 bytes
ovs
2
i,es solo una abreviatura de (i,), que es una tupla que contiene a. a,*x = x or [0]es el desempaquetado extendido de python3 . Aquí hay una publicación SO útil sobre este tema con algunos ejemplos.
ovs
6

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.

Asistente de trigo
fuente
1
Reemplazar head acon a!!0guarda un byte.
tomsmeding
5

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
marinus
fuente
Guardar un byte con {⍵≡⍬:⍬⋄(⊂⍵~r),∇r←⍵/⍨⍵<⌈\⍵}. Morten está preocupado por la falta de respuesta a sus correos electrónicos. ¿Está todo bien?
Adám
Oh querido. Estoy feliz de que hayas logrado. Te veo la proxima semana.
Adám
4

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
  ]

Rick Hitchcock
fuente
1
Por una fracción de segundo, pensé que ?!era un nuevo operador elegante ...
Neil
Ja, sí, debería haber incluido una explicación. Ahora agregado.
Rick Hitchcock
@Neil?!
Patrick Roberts
(i,n,o=[])=>[i.filter(a=>(n||a)<=a?(n=a,1):!o.push([a])),...o]Aparentemente, las grandes mentes piensan (más o menos) igual. Desafortunadamente, parece que no puedo eliminar más bytes ... Solo notando que puedes eliminar f=tu código, y tal vez mi código podría darte algunas ideas sobre cómo jugar al tuyo aún más.
David Archibald
Gracias, @DavidArchibald. No puedo eliminarlo f=de mi código, porque es recursivo. El suyo es un enfoque interesante, pero no parece funcionar para algunos de los casos de prueba. Por ejemplo, vuelve [[5,8],[4],[3],[7],[6]] para el penúltimo caso.
Rick Hitchcock
4

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.

JAD
fuente
4

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
Kevin Cruijssen
fuente
¿Se puede usar en try{}catch{}lugar de verificar l.size()para guardar algunos?
TheLethalCoder
1
Puede iniciar el bucle interno en 0y eliminar los corchetes del bucle for externo l->{List r=new Vector(),t;for(int p,i,x;l.size()>0;)for(p=l.get(0),r.add(t=new Vector()),i=0;i<l.size();p=x)if((x=l.get(i++))>=p)t.add(l.remove(--i));return r;}(-3 bytes).
Nevay
3

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!

TheLethalCoder
fuente
@RickHitchcock Corregido a un costo de 15 bytes! Bonito lugar.
TheLethalCoder
Buen trabajo:) +1
Rick Hitchcock
3

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:;
 }
}
Karl Napf
fuente
Probablemente pueda salirse con la suya omitiendo el R.clear(), y solo requerir que la persona que llama comience con un contenedor vacío.
Peter Cordes
Buena idea de @PeterCordes, podría respetar mis otras respuestas de C ++ que presentaron retorno a través del parámetro de referencia.
Karl Napf
2

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

Zarigüeya muerta
fuente
1
88 bytes simplemente sacándolo de su función.
Arnold Palmer
1

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
  }
}
Alex Axthelm
fuente
probablemente deberías eliminar esto por el momento para que no obtengas votos negativos mientras lo arreglas.
Giuseppe
1
z=function(x)"if"(sum(x|1),{a=x[(i=x>=cummax(x))] c(list(a),z(x[!i]))},NULL)funciona
Giuseppe
el espacio entre ]y ces una nueva línea (o punto y coma)
Giuseppe
Nunca he visto "if"antes, pero soy bastante nuevo en R golf. Deberías publicar como tu propia respuesta, y yo puedo tomar la mía. Me gusta lo que hiciste con el iíndice, para %in%solucionar el problema.
Alex Axthelm
¡No, hiciste todo el trabajo duro! No pude entender este problema hasta que vi su implementación, ¡nunca lo habría recordado cummax!
Giuseppe
1

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}

Patrick Roberts
fuente
1
&&oes un byte más corto que (,o).
Neil
@Neil gah! Gran captura, gracias
Patrick Roberts
1
Me gusta tu [...b].pop(), pero creo que (o.find(b=>[...b].pop()<=n)||(n=[n],o)).push(n)te ahorra un byte o dos.
Neil
A este ritmo, me sentiré obligado a marcar esto como una publicación de la comunidad ... maldición
Patrick Roberts
¿Solo por un par de ajustes? Sigue siendo básicamente el mismo código ...
Neil
1

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("");
    }
}
Felix Palmen
fuente
175 bytes .
Sr. Xcoder
Uhh, por supuesto, qué estúpido, ¡gracias!
Felix Palmen
1

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

Paraguas
fuente
1

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;
}
WebSmithery
fuente
1
Teniendo en cuenta los 31 caracteres que dejé fuera <?php function d($a){return$r;}, me aplastó de todo corazón. Aparte, me acabo de dar cuenta de que ambos olvidamos la salida.
Paraguas
He estado probando mi solución para intentar vencer la tuya sin usar la tuya y encontré una manera de mejorar la tuya: creo que puedes salvar cuatro caracteres reemplazándolos $v<max($l)?$f[]=$v:$l[]=$v;con ${$v<max($l)?f:l}[]=$v;, al menos, funciona en mis pruebas.
Paraguas
@Umbrella, ¿no regresa y sale ??? Y gracias por esos 4 bytes. Nunca pienso en trabajar así, usando código para evaluar el nombre de la variable. Debo recordar tener en cuenta que en futuros desafíos ... 🤔
WebSmithery
Encontrado, el consenso parece aceptar el retorno como resultado: codegolf.meta.stackexchange.com/questions/2447/…
Umbrella
0

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?

Tal vez sea así
fuente
0

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
Pálido
fuente
0

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)
Zacharý
fuente
{⍬≢⍴⍵}puede convertirse(⍬≢⍴)
Kritixi Lithos
Ya lo hice sin ver su comentario,
Zacharý
¿Para qué sirve {(⍵/⍨~E),⊂⍵/⍨E←(⍬≡⍴)¨⍵}? Parece estar separado de todo lo demás
Kritixi Lithos
Sin él, el primer caso de prueba sería algo así [[1,2,5,7],[4],3], en lugar de lo requerido [[1,2,5,7],[4],[3]].
Zacharý
Es posible que pueda acortar ese dfn a solo(,¨)
Kritixi Lithos
0

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! .

Zacharý
fuente
0

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!

Stan Strum
fuente
¿Tienes que usar var?
Zacharý
@ Zacharý, déjame comprobar!
Stan Strum
Los parens no son necesarios alrededor x.
Zacharý