Як описано в цьому запитанні :

Dropsort, розроблений Девідом Морган-Мар, є прикладом лінійного "алгоритму сортування" за лінійним часом, який створює список, який насправді відсортований, але містить лише деякі оригінальні елементи. Будь-який елемент, який не менше як максимум елементів, що передують йому, просто видаляється зі списку та відкидається.

Для того, щоб використовувати один зі своїх тестових прикладів, введення {1, 2, 5, 4, 3, 7}врожайності {1, 2, 5, 7}, як 4і 3обидва впали за те , що менше , ніж раніше «упорядковано» значення, 5.

Ми не хочемо "сортувати" алгоритми, ми хочемо, щоб вони були справжньою угодою. Тому я хочу, щоб ви написали програму, яка, виходячи зі списку чисел, виводить список списків DropSorted (щоб бути повноцінним алгоритмом сортування, нам потрібно було б об'єднати ці списки, але об'єднання двох відсортованих списків було зроблено раніше, і прошу вас зробити це ще раз, задаючи два запитання, тому це питання є конкретно кроком "розщеплення" нашого повного DropSort).

Впорядкування та зміст наших списків є вирішальним. Вихід вашої програми повинен бути еквівалентний виводу DropSort, за яким слідує DropSort відкинутих значень тощо, поки у вас є лише список відсортованих ланцюгів. І знову запозичення існуючого тестового набору (та додавання ще двох):

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

Ви можете припустити, що введення не порожнє.

Це код-гольф , тому застосовуються стандартні правила!

MATL , 15 10 9 байт

5 байт вимкнено, використовуючи ідею @beaker про сукупний максимум

t"ttY>=&)

Введення - це числовий векторний рядок у форматі [1, 2, 5, 4, 3, 7](коми не є обов'язковими). Вихід містить списки, розділені новими рядками, при цьому числа в кожному списку розділені пробілами.

Спробуйте в Інтернеті! Або перевірити всі тестові випадки .

Пояснення

З огляду на масив, код вибирає з нього кожен запис, який дорівнює сукупному максимуму до цього запису.

Наприклад, дано

1 2 5 4 3 7

код вибирає перший, другий, третій та шостий записи:

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ü<¡Ṡ-ü<

Спробуйте в Інтернеті!

Це поєднання моєї іншої відповіді Хука та Хаскеллської відповіді xnor . Дублікат ü<здається незграбним, але я не знаю, як його позбутися ...

Пояснення

Функція ü<перекладається на nubBy(>)Haskell. Він переходить список зліва направо, зберігаючи ті елементи, для яких жодного раніше збереженого елемента суворо більше. Іншими словами, він виконує капсулу. Елементи, що залишилися, отримуються шляхом взяття різниці у списку вихідного списку та результату ü<.

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▲

Спробуйте в Інтернеті!

Пояснення

Цей перший рядок є основною функцією, а другий - допоміжною функцією вищого порядку (він приймає функцію як аргумент і повертає нову функцію). Доступ до нього здійснюється через індекс ₁. Ідея полягає в тому, що ₁≤виконує дроборт і ₁>надає елементам, що залишилися.

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

В основній функції ми повторюємо функцію залишків ₁>і застосовуємо до результатів функцію droport ₁≤.

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

Пітон 3 , 131 112 103 95 байт

Велике спасибі @Mr. Xcoder для чудових 19 байт !!

Велике спасибі @ovs за дивовижні 17 байт!

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

Haskell , 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бульний вектор довжини , де всі ІСТИНИ відповідають сортованим значенням. Ми використовуємо це для отримання підмножини 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;}

-3 байт завдяки @Nevay .
-2 байти, використовуючи Stackзамість 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 #, 188 203 байт

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 байт

Використання алгоритму з відповіді Haskell w0lf .

Як безіменна родова лямбда. Перший параметр є контейнером значень, що підпадає під розрідження (подібний vector<int>), а другий параметр вимагає сумісного порожнього контейнера контейнерів (наприклад vector<vector<int>>) для зворотного значення через посилання.

У першій версії програми було R.clear;()як перше твердження, так що контейнер контейнерів не повинен бути порожнім. Пітер Кордес подумав, що це може входити в специфікацію, тому скинувши 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 байт

-4 байти завдяки Арнольду Палмеру

b,r=input(),[]
for i in b:
 for l in r:
	if l[-1]<=i:l+=[i];break
 else:r+=[[i]]
print r

Спробуйте в Інтернеті!

Рішення, подібне до haskell @ w0lf [відповідь] [1]

Випадок рідкісного використання для for-elseбудівництва

Ітерація через відсортовані списки for l in r(порожні на початку).
Якщо елемент (з введення) iбільший за останній елемент списку l[-1], додайте елемент до списку l+=[i], перервіть.
Якщо список не прийнято, додайте новий список із цими елементами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)в ...&&oі повторно організувати зворотний виклик , map()щоб бути більш компактним.

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 байт

(Відредаговано, щоб додати 12 символів print_r($r);для задоволення вимоги до виводу)
(Відредаговано для видалення 7 байтів, коли дозволено помилки PHP)
(Відредаговано, щоб видалити 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;
}

Зовнішній цикл псевдорекурсивної ініціалізації ініціалізує масиви зберігання $bта відкидання $dпорожніми, потім робить базовий цикл сортування крапель, нарешті встановлюючи відкидання як новий вхід і додаючи збереження до результату$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;

Якщо в списку є щось $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 опосума відповідь .
Дописує кожен член xз wдо першого списку в a{списку списків} з xвеликим , ніж в останньому елементі.
якщо немає, додається [x]до a.

Мені б дуже хотілося, якби existsповернули, aякби нічого не було знайдено! Також намагаюся застосувати однолінійну ідею @ Officialalaimm ...

Питання: Якщо я видалив свій код з функції, мені доведеться призначити 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}

В основному, запитує, чи більше поточного елемента, ніж останній, додати до першого списку. В іншому випадку додайте до другого.

Під час цього з'ясувалося, що порівнювати будь-яке число 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

Спробуйте в Інтернеті!