Come descritto in questa domanda :

Dropsort, progettato da David Morgan-Mar, è un esempio di "algoritmo di ordinamento" a tempo lineare che produce un elenco che, in effetti, è ordinato, ma contiene solo alcuni degli elementi originali. Qualsiasi elemento che non sia grande almeno quanto il massimo degli elementi che lo precedono viene semplicemente rimosso dall'elenco e scartato.

Per usare uno dei loro casi di test, un ingresso di {1, 2, 5, 4, 3, 7}rendimenti {1, 2, 5, 7}, come 4e 3sono entrambi sceso per essere più piccolo del precedente "ordinato" Valore, 5.

Non vogliamo algoritmi di "ordinamento", vogliamo che siano il vero affare. Pertanto, voglio che tu scriva un programma che, dato un elenco di numeri, genera un elenco di elenchi DropSorted (per essere un algoritmo di ordinamento completo, avremmo bisogno di unire questi elenchi, ma in precedenza è stato fatto l' unione di due elenchi ordinati , e chiederti di farlo di nuovo significa praticamente fare due domande, quindi questa domanda è in particolare il passaggio "di divisione" del nostro DropSort completo).

La disposizione e il contenuto dei nostri elenchi è tuttavia fondamentale. L'output del programma deve essere equivalente all'output di un DropSort, seguito da un DropSort dei valori scartati e così via fino a quando non si dispone solo di un elenco di catene ordinate. Ancora una volta, prendendo in prestito la suite di test esistente (e aggiungendone altre due):

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

È possibile supporre che l'input non sia vuoto.

Questo è code-golf , quindi si applicano le regole standard!

MATL , 15 10 9 byte

5 byte di sconto usando l'idea del massimo cumulativo di @beaker

t"ttY>=&)

L'input è un vettore di riga numerico, nel formato [1, 2, 5, 4, 3, 7](le virgole sono facoltative). L'output contiene liste separate da newline, con i numeri in ciascuna lista separati da spazi.

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

Dato un array, il codice seleziona da esso ogni voce uguale al massimo cumulativo fino a quella voce.

Ad esempio, dato

1 2 5 4 3 7

il codice seleziona la prima, la seconda, la terza e la sesta voce:

1 2 5     7

Quindi il processo viene ripetuto sul sottoarray formato dalle voci rimanenti (nell'ordine originale):

      4 3

Questo deve essere fatto fino a quando il sottoarray delle voci rimanenti è vuoto. Un limite superiore al numero richiesto di iterazioni è la dimensione di input. Le ultime iterazioni potrebbero non essere necessarie. In tal caso operano su un array vuoto, producendo ulteriori array vuoti.

Alla fine, la pila contiene gli array richiesti e possibilmente diversi array vuoti, che non vengono visualizzati affatto.

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 byte

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

Spiegazione: Dato un elenco di elenchi (che sono già ordinati) e un valore x, l' !operatore posizionerà xalla fine del primo elenco il cui ultimo elemento è minore o uguale a x. Se tale elenco non esiste, l'elenco [x]viene posizionato alla fine.

Provalo online.

Buccia , 10 byte

hUmü<¡Ṡ-ü<

Provalo online!

Questa è una combinazione della mia altra risposta Husk e della risposta Haskell di xnor . Il duplicato ü<sembra goffo, ma non so come liberarmene ...

Spiegazione

La funzione si ü<traduce in nubBy(>)in Haskell. Attraversa un elenco da sinistra a destra, mantenendo quegli elementi per i quali nessun elemento precedentemente conservato è strettamente maggiore. In altre parole, esegue dropsort. Gli elementi rimanenti si ottengono prendendo la differenza di elenco tra l'elenco originale e il risultato di ü<.

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 byte

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

Provalo online!

Buccia , 16 byte

hUm₁≤¡₁>
ṠfSz⁰G▲

Provalo online!

Spiegazione

Questa prima riga è la funzione principale e la seconda è una funzione di supporto di ordine superiore (accetta una funzione come argomento e restituisce una nuova funzione). Vi si accede dal pedice ₁. L'idea è che ₁≤esegue dropsort e ₁>fornisce gli elementi rimanenti.

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

Nella funzione principale, ripetiamo la funzione rimanenti ₁>e applichiamo la funzione dropsort ₁≤ai risultati.

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 byte

Grazie mille @Mr. Xcoder per un incredibile 19 byte !!

Grazie mille @ovs per ben 17 byte!

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

Provalo online!

Spiegazione:

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 byte

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

Provalo online!

Questo sembra davvero lungo.

Spiegazione

!esegue l'ordinamento di rilascio in un elenco, mentre #raccoglie i ritagli. gquindi si applica ripetutamente #fino a quando l'elenco è vuoto registrando i risultati in un elenco.

APL, 27 byte

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

Spiegazione:

• ⍵≡⍬:⍬: se l'input è vuoto, restituisce l'elenco vuoto
• X←⍵≥⌈\⍵: tutti i numeri maggiori o uguali al massimo corrente
• (⊂X/⍵): l'elenco di quei numeri,
• ∇⍵/⍨~X: seguito dal risultato dell'esecuzione di questa funzione sui numeri rimanenti

JavaScript (ES6), 64 byte

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]

R , 61 byte

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

Provalo online!

Funzione ricorsiva. sum(x|1)è una scorciatoia per length(x), quindi questa ricorsione verrà eseguita fino a quando non xsarà vuota. cummaxprende il massimo cumulativo di x, che viene quindi confrontato di xnuovo. Questo produce un vettore booleano di lunghezza x, in cui tutti i VERO corrispondono a valori ordinati. Usiamo che per prendere un sottoinsieme di xe printesso. La funzione viene quindi richiamata nuovamente sul resto di x.

Java 8, 182 179 177 byte

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 byte grazie a @Nevay .
-2 byte usando Stackinvece di Vector.

Spiegazione:

Provalo qui.

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 byte

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

Il conteggio dei byte include +18 per:

using System.Linq;

Provalo online!

C ++ 14, 118 108 byte

Usando l'algoritmo dalla risposta Haskell di w0lf .

Come lambda generico senza nome. Il primo parametro è un contenitore dei valori da dropsort (come vector<int>) e il secondo parametro richiede un contenitore vuoto compatibile di contenitori (comevector<vector<int>> ) per il valore di ritorno tramite riferimento.

Nella prima versione del programma, c'era R.clear;()la prima istruzione, quindi il contenitore dei contenitori non doveva essere vuoto. Peter Cordes ha pensato che ciò potesse rientrare nelle specifiche, quindi ha perso 10 byte per quello.

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

Provalo 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:;
 }
}

Python 2 , 88 byte

-4 byte grazie ad 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

Provalo online!

Soluzione simile a haskell di @w0lf [risposta] [1]

Caso d'uso raro per la for-elsecostruzione

Scorrere gli elenchi ordinati for l in r(vuoto all'inizio).
Se l'elemento (dall'input) iè più grande dell'ultimo elemento dell'elenco l[-1], aggiungi l'elemento all'elenco l+=[i], interrompi.
Se nessun elenco è stato accettato, aggiungi un nuovo elenco con questo elemensr+=[[i]]

R, Lavori in corso (89, ma non funzionanti)

Tenendo un po 'di lavoro qui, perché mi sono arretrato in un angolo usando %in%(non riesce su voci duplicate, in particolare l'ultimo caso di test), e devo andare a fare altre cose ora, ma questo è qui se qualcuno vuole costruirci sopra:

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

Ungolfed:

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 byte

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

Abbastanza semplice, esegue l'iterazione dell'array, cerca il primo array interno il cui ultimo valore è <=il valore successivo da eliminare, se non esiste, aggiungi un nuovo array interno con il valore successivo all'output, altrimenti aggiungi il valore successivo al primo trovato array interno che corrisponde alla condizione.

aggiornamenti

Grazie a Neil, salvati tre byte conversione (...,o)di ...&&oe ri-organizzare la richiamata ad map()essere più compatto.

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 byte

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

Provalo online!

C (gcc) , 176 175 173 byte

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

Provalo online!

Versione un po 'leggibile:

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

(Modificato per aggiungere 12 caratteri di print_r($r);per soddisfare i requisiti di output)
(Modificato per rimuovere 7 byte quando si consentono errori PHP)
(Modificato per rimuovere 11 byte quando si golfizza ulteriormente l'assegnazione)

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

Dato input $a, produce risultati$r

Bella:

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

Il ciclo esterno pseudo-ricorsivo inizializza gli array keep $band scarard $dsu vuoto, quindi esegue un loop di ordinamento drop di base, impostando infine gli scarti come nuovo input e aggiungendo gli keep al risultato$r

PHP , 102 byte , 98 byte

<?php function s($i){static$s;foreach($i as$v)${$v<max($l)?f:l}[]=$v;$s[]=$l;!$f?:s($f);return$s;}

Provalo online!

-4 byte, grazie a @Umbrella

Spiegazione

<?php

La funzione accetta l'elenco di input come un array.

function s($i) {

$s, che diventerà l'elenco degli elenchi finalmente restituiti, viene dichiarato statico. Ciò estende il suo ambito di applicazione a tutte le chiamate di questa funzione, consentendo alla funzione di essere chiamata in modo ricorsivo senza dover passare questo elenco di risultati come argomento o restituirlo.

    static $s;

Passa attraverso ogni valore nell'elenco.

    foreach ($i as $v)

È inferiore al più grande membro dell'elenco corrente?

        $v < max($l) ?

Sì, inseriscilo nell'elenco $fper ulteriori ordinamenti.

                        $f[] = $v :

No, mettilo in lista $l.

                        $l[] = $v;

Spingere l'elenco $lnell'elenco di elenchi.

    $s[] = $l;

Se c'è qualcosa nell'elenco $f, invialo di nuovo in giro per un ulteriore ordinamento.

    !$f ?: s($f);

Restituisce l'elenco degli elenchi.

    return $s;
}

Salvia, 102 byte

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

Molto simile a quella di @Dead Possum risposta .
Aggiunge ogni membro xdella walla prima lista in a{} lista di liste con xmaggiore di quanto non di ultimo elemento.
Se nessuno, aggiunge [x]a a.

Mi piacerebbe davvero se existsrestituito ase non fosse stato trovato nulla! Anche cercando di applicare l' idea di una riga di @ officialaimm ...

Domanda: se avessi rimosso il mio codice dalla funzione, avrei dovuto assegnare wl'input giusto? Quindi risparmierebbe byte?

Ocaml , 69 62 byte

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

Spiegazione:

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 byte

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

-0 byte grazie a Lithos Kritixi ...

Provalo online!

Ci deve essere un modo migliore per farlo ( c'è ). Tutti i suggerimenti sono molto apprezzati e benvenuti.

Come?

(Nota, alcune di queste spiegazioni potrebbero essere errate, poiché ho dimenticato come funzionava)

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

Gelatina, 26 byte

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

Questo è lo stesso metodo della risposta APL di Marinus.

Provalo online! .

JavaScript (Node.js) , 125 109 106 byte

- 16 18 byte da Zacharý

-1 rimuovendo {e} modificando l'incremento per includere il "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}

Fondamentalmente, chiede è l'elemento corrente maggiore dell'ultimo elemento, aggiungere al primo elenco. Altrimenti, aggiungi al secondo.

Durante questo ho scoperto che confrontando qualsiasi numero con NaN risultato sarà sempre ilfalse . Interessante!

Spiegazione:

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

Provalo online!