이 질문에 설명 된대로 :

David Morgan-Mar이 디자인 한 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}}

입력이 비어 있지 않은 것으로 가정 할 수 있습니다.

이것은 code-golf 이므로 표준 규칙이 적용됩니다!

MATL , 15 10 9 바이트

@beaker 의 누적 최대 값 아이디어를 사용하여 5 바이트 꺼짐

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

하스켈, 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ü<¡Ṡ-ü<

온라인으로 사용해보십시오!

이것은 내 다른 Husk 답변 과 xnor의 Haskell answer의 조합입니다 . 복제품 ü<은 어리석은 느낌이 들지만 그것을 제거하는 방법을 모르겠습니다 ...

설명

이 함수 는 Haskell에서 ü<번역됩니다 nubBy(>). 리스트는 왼쪽에서 오른쪽으로 순회하며 이전에 유지 된 요소가없는 요소는 엄격하게 유지합니다. 즉, 액 적을 수행합니다. 남은 요소는 원본 목록과의 결과를 목록 차이로 가져옵니다 ü<.

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

하스켈 , 50 바이트

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

온라인으로 사용해보십시오!

껍질 , 16 바이트

hUm₁≤¡₁>
ṠfSz⁰G▲

온라인으로 사용해보십시오!

설명

이 첫 번째 줄은 주 함수이고 두 번째 줄은 상위 도우미 함수입니다 (함수를 인수로 사용하여 새 함수를 반환 함). 아래 첨자에 의해 액세스됩니다 ₁. 아이디어는 ₁≤droport 를 수행 ₁>하고 남은 요소를 제공한다는 것입니다.

Ṡ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 , 13111210395 바이트

감사합니다 @Mr. 스매싱 19 바이트를위한 Xcoder !!

놀라운 17 바이트에 대해 @ovs에게 감사드립니다!

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

하스켈 , 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: 나머지 숫자에서이 기능을 실행 한 결과

자바 스크립트 (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)재귀는 l x이 비어 있을 때까지 실행됩니다 . cummax누적 최대 값 인 x을 사용하여 x다시 비교 합니다. 이렇게하면 length의 부울 벡터가 생성 x되며 모든 TRUE는 정렬 된 값에 해당합니다. 우리는 그것을 사용 x하여 print그것 의 부분 집합을 취 합니다. 그런 다음의 나머지 부분에서 함수가 다시 호출됩니다 x.

자바 (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;}

@Nevay 덕분에 -3 바이트 . 대신에
2 바이트 사용StackVector .

설명:

여기에서 시도하십시오.

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, 118108 바이트

w0lf의 Haskell 답변의 알고리즘 사용 .

명명되지 않은 일반 람다. 첫 번째 매개 변수는 droport 할 값의 컨테이너 (예 :) vector<int>이고 두 번째 매개 변수는 호환 가능한 빈 컨테이너 컨테이너 (예 :vector<vector<int>> 참조를 통한 리턴 값에 대해 .

프로그램의 첫 번째 버전에는 R.clear;()첫 번째 문장이 있었으므로 컨테이너 컨테이너는 비워 둘 필요가 없습니다. Peter Cordes는 이것이 사양에 포함될 수 있다고 생각했기 때문에 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:;
 }
}

파이썬 2 , 88 바이트

Arnold Palmer 덕분에 -4 바이트

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

온라인으로 사용해보십시오!

@ w0lf의 haskell과 유사한 솔루션 [answer] [1]

for-else건설을 위한 희귀 사용 사례

정렬 된 목록을 반복합니다 for l in r(시작시 비어 있음).
element (from input) i이 list의 마지막 요소보다 큰 경우 list l[-1]에 요소를 추가 l+=[i]하고 중단하십시오.
수락 된 목록이없는 경우이 elemens로 새 목록을 추가하십시오.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
  }
}

자바 스크립트 (ES6), 71 70 68 바이트

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

아주 간단하고 배열을 반복하고 마지막 값이 <=다음으로 떨어지는 값을 가진 첫 번째 내부 배열을 찾습니다. 없는 경우 다음 값을 가진 새로운 내부 배열을 출력에 추가하고 그렇지 않으면 다음 값을 첫 번째에 추가합니다 조건과 일치하는 내부 배열을 찾았습니다.

업데이트

Neil 덕분에 콜백으로 변환 하고 재구성 (...,o)하기 위해 3 바이트를 절약 할 수있었습니다....&&omap()

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}

apt , 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 바이트

( print_r($r);출력 요구 사항을 충족하기 위해 12자를 추가
하도록
편집 됨 ) ( PHP 오류를 허용 할 때 7 바이트를 제거하도록 편집 됨 ) (할당을 더 골프를 칠 때 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;}

온라인으로 사용해보십시오!

@Umbrella 덕분에 -4 바이트

설명

<?php

이 함수는 입력 목록을 배열로 사용합니다.

function s($i) {

$s마지막으로 반환 된 목록의 목록이되는을 정적으로 선언합니다. 이것은 범위를 이 함수의 모든 호출로 확장 하여이 결과 목록을 인수로 전달하거나 리턴 할 필요없이 함수를 재귀 적으로 호출 할 수있게합니다.

    static $s;

목록의 각 값을 반복합니다.

    foreach ($i as $v)

가장 큰 현재 목록 회원보다 적습니까?

        $v < max($l) ?

예, $f추가 정렬을 위해 목록 에 추가하십시오.

                        $f[] = $v :

아니요, list에 넣으십시오 $l.

                        $l[] = $v;

목록 $l을 목록 목록 으로 푸시하십시오 .

    $s[] = $l;

list에 어떤 것이 있으면 $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 Possum의 답변 과 매우 유사합니다 .
각 요소 멤버 x를 마지막 요소보다 큰 {list of list} w의 첫 번째 목록에 추가합니다 . 없는 경우에 추가 합니다 . ax
[x]a

아무것도 발견되지 않으면 exists반환 a되면 정말 좋아합니다 ! 또한 @officialaimm의 단선 아이디어 를 적용하려고합니다 ...

질문 : 함수에서 코드를 제거 w하면 입력 권한 을 할당 해야합니까? 바이트를 절약 할 수 있습니까?

오캄 , 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/⍵)}

Kritixi Lithos 덕분에 -0 바이트 ...

온라인으로 사용해보십시오!

(이 작업을 수행하는 더 좋은 방법이있을거야 있습니다 ). 모든 팁은 대단히 감사하고 환영합니다.

어떻게?

(이 작동 방식을 잊어 버렸 으므로이 설명 중 일부가 잘못되었을 수 있습니다)

{⍵≡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 답변과 같은 방법입니다.

온라인으로 사용해보십시오! .

자바 스크립트 (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

온라인으로 사용해보십시오!