David Morgan-Mar이 디자인 한 Dropsort 는 실제로 정렬되어 있지만 일부 원래 요소 만 포함하는 목록을 생성하는 선형 시간 "정렬 알고리즘"의 예입니다 . 그 앞에있는 요소의 최대 값보다 크지 않은 요소는 목록에서 제거되어 삭제됩니다.

이 작업에서는 정수 목록을 입력으로 받게됩니다 (STDIN 또는 함수 인수, 최소한 8 비트 부호있는 정수 범위를 지원해야합니다). 주문.

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

이것은 코드 골프이므로 가장 짧은 프로그램이 승리합니다.

테스트 사례

Input             Output
1 2 5 4 3 7       1 2 5 7
10 -1 12          10 12
-7 -8 -5 0 -1 1   -7 -5 0 1
9 8 7 6 5         9
10 13 17 21       10 13 17 21
10 10 10 9 10     10 10 10 10

리더 보드

var QUESTION_ID=61808,OVERRIDE_USER=39022;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

APL, 9 바이트

⊢(/⍨)⊢=⌈\

이것은 다이어그램이있는 모나 딕 기능 열차입니다.

┌─┼───┐  
⊢ ⍨ ┌─┼─┐
┌─┘ ⊢ = \
/     ┌─┘
      ⌈  

비 열차 버전은

{⍵/⍨⍵=⌈\⍵}

기본적으로 각 요소가 실행 최대 값과 같은지 확인합니다.

참고 마틴 있음 Büttner의 J 솔루션은 이 같은 길이이며, 처음 게시했습니다.

J, 10 9 바이트

#~(=>./\)

내 CJam 아이디어의 작업 버전 (더 적은 바이트). 예 :

   f =: #~(=>./\)
   f 10 10 10 9 10
10 10 10 10
   f 1 2 5 4 3 7
1 2 5 7

설명

먼저 다음과 같이 각 접두어의 최대 값을 얻습니다.

    >./\

(여기서는 >.최대 연산자이며 /해당 연산자를 목록에 접어 \입력의 모든 접두사를 가져옵니다.)

그런 다음 초기 목록과 그 최대 값을 비교합니다.

  (=>./\)

마지막으로,이 부울 결과 목록에 다음과 같은 모든 요소를 ​​선택합니다 1.

#~(=>./\)

하스켈, 28

foldr(\x l->x:filter(x<)l)[] 

익명의 기능. 처럼 불러

foldr(\x l->x:filter(x<)l)[] [-7, -8, -5, 0, -1, 1] 
[-7,-5,0,1]

재귀에 해당

f[]=[]
f(x:l)=x:filter(x<)(f l)

반복적으로 번역하면 요소를 반복하고 우리가 보는 각 요소마다 반복하는 목록의 나머지 부분에서보다 작은 요소를 제거합니다. 로 저장된 바이트에 대한 Antisthenes에게 감사합니다 (x<).

파이썬 2, 49

f=lambda a:a and f(a[:-1])+a[-1:]*(a[-1]==max(a))

자바 스크립트 (ES6), 29

자바 스크립트에서 표준 유형 변환을 사용하지 않고 배열을 숫자로 변환합니다.

• 단지 1 숫자의 배열 => 그 숫자
• 다른 배열 => NaN

d=l=>l.filter(v=>l>v?0:[l=v])

// TEST
console.log=x=>O.innerHTML+=x+'\n'

;[
  [[1,2,5,4,3,7], [1,2,5,7]]
, [[10,-1,12], [10,12]]
, [[-7,-8,-5,0,-1,1], [-7,-5,0,1]]
, [[9,8,7,6,5], [9]]
, [[10,13,17,21], [10,13,17,21]]
, [[10,10,10,9,10], [10,10,10,10]]
].forEach(t=>( i=t[0],r=d(i),x=t[1],              
  console.log('Test '+i+' -> '+r+(r+''==x+''?' OK':' Fail (expected '+x+')')))
)

<pre id=O></pre>

옥타브, 27 19 바이트

@(a)a(cummax(a)==a)

Pyth, 12 바이트

eMfqeTeST._Q

모든 테스트 사례를 한 번에 확인하십시오.

작동 원리

         ._Q  Compute all prefixes of the input.
  f           Filter; for each T in the prefixes:
    eT          Retrieve the last element of T.
      eST       Sort T and retrieve its last element.
   q            Check for equality.
              Keep T if q returned True.
eM            Select the last element of each kept T.

Brachylog , 5 바이트

⊇ᶠ↔ᵒt

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

젤리 , 5 바이트

ŒPUÞṪ

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

설명

⊇ᶠ↔ᵒt    ŒPUÞṪ
⊇ᶠ       ŒP       On all subsequences of {the input}
   ᵒ        Þ     sort by
  ↔        U      their reverse
    t        Ṫ    then take the last element (i.e. the maximum as given by the sort)

이것은 드문 상황입니다. 아무도 지금까지 사용하지 않는 알고리즘을 사용합니다 (빠른 탈지로 말할 수있는 한), 어쨌든 매우 다른 구문을 가진 두 개의 매우 다른 골프 언어에서 동일한 길이를 얻습니다. 프로그램간에 일대일로 대응되는 내장 세트 (명령은 동일한 순서로도 제공됨). 그래서 그것들을 결합하는 것이 더 의미가있는 것처럼 보였습니다 – 어떤 방식으로, 이것들은 같은 프로그램이며, 그것들을 따로 제출하는 것보다 더 짧은 것을보기 위해 두 언어로 작성했습니다.

여기서 기본적인 아이디어는리스트의 드롭 정렬이 사전 식으로 최대 역수의 하위 시퀀스라는 것입니다. 이상하게도 Brachylog 나 Jelly 모두 특정 함수로 최대 값을 찾는 내장 기능이 없습니다 (Jelly에는 특정 함수로 모든 최대 값 을 반환하는 내장 기능이 있지만 결과 자체가 아닌 결과가 포함 된 단일 목록을 반환합니다. 이 방법으로 수행하는 것보다 짧지는 않습니다). 대신, 우리는 가능한 모든 하위 시퀀스를 생성하고 역순으로 정렬하여 마지막을 취합니다.

"사 전적으로 최대 역전"이 작동하는 이유는 선택한 출력이 입력 목록에서 가장 높은 숫자로 끝나야하므로 (반전이 시작되어야 함), Dropsort 출력이 항상 그 결과로 끝나는 것을 쉽게 알 수 있기 때문입니다. 하위 시퀀스를 사용하면 순서가 유지되므로 그 이후에는 아무것도 포함하지 않습니다. 귀납적으로 반복하고 우리는 dropsort의 정의로 끝납니다.

수학, 26 바이트

DeleteDuplicates[#,#>#2&]&

R, 29 26 바이트

function(x)x[x>=cummax(x)]

이 함수는 벡터를 받아들이고 누적 최대 값보다 크지 않은 모든 요소를 ​​제거한 후 x반환 하는 함수 객체를 만듭니다 .xx

flodel 덕분에 3 바이트를 절약했습니다!

K, 11 바이트

{x@&~x<|\x}

실제로 :

  f: {x@&~x<|\x}
  f'(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)

(1 2 5 7
 10 12
 -7 -5 0 1
 ,9
 10 13 17 21
 10 10 10 10)

자바, 82 바이트

void f(int[]a){int m=a[0];for(int n:a){System.out.print(m>n?"":n+" ");m=n>m?n:m;}}

다음은 간단한 출력 루프입니다. 최대 값을 유지하고 m각 요소를 비교합니다.

펄, 33 바이트

32 바이트 코드 + -p

$p=$_;s/\S+ ?/$&>=$p&&($p=$&)/ge

추가 공간의 출력에 허용되는 경우, 제거하여 31 바이트 수 와 ?. 다음을 통해 문자열 (또는 개행 문자로 구분 된) 문자열을 허용합니다 STDIN.

perl -pe'$p=$_;s/\S+ ?/$&>=$p&&($p=$&)/ge' <<< '-7 -8 -5 0 -1 1'
-7 -5 0 1

perl -pe'$p=$_;s/\S+ ?/$&>=$p&&($p=$&)/ge' <<< '10 10 10 9 10'
10 10 10 10

파이썬 3, 67

꽤 무차별 한 힘. 올바른 답변이라고 생각하지 못했기 때문에 함수로 변경했습니다.

def f(i):
 s=[i[0]]
 for n in i[1:]:
  if s[-1]<=n:s+=[n]
 return s

언 골프 버전 :

input_numbers = input().split()
sorted_numbers = []
previous_number = int(input_numbers[0])
for number in map(int, input_numbers):
    if previous_number <= number:
        sorted_numbers.append(number)
        previous_number = number
print(sorted_numbers)

하스켈, 38 37 바이트

JArkinstall 덕분에 1 바이트가 절약되었습니다 .

f(x:y:s)|x>y=f$x:s|1>0=x:f(y:s)
f s=s

씨# - 6864 또는 132127 자

int[]f(int[]b){return b.Where((v,i)=>i<1||b[i-1]<=v).ToArray();}

Where이 경우 목록을 반복하고 목록의 v색인 i에있는 각 요소 에 대해 부울 표현식을 평가합니다. 표현식이 true로 평가되면 항목이 결과에 추가됩니다. 부울 식에 대한 유일한 실제 트릭은 조건이 true로 평가되는 즉시 C # 단락 또는 평가입니다. 이는 IndexOutOfRangeException예외를 방지하고 목록의 첫 번째 요소를 유지합니다.

입력과 출력이 문자열이어야하는 경우 (확실히 알 수 없으므로 OP와 나머지에게 맡겨 결정해야합니다.)

string t(string b){var c=b.Split(' ').Select(d=>int.Parse(d)).ToList();return String.Join(" ",c.Where((v,i)=>i<1||c[i-1]<=v));}

압축을 풀면 다음이 제공됩니다.

string t(string b) 
{
    var c=b.Split(' ').Select(d=>int.Parse(d)).ToList();
    return String.Join(" ",c.Where((v, i)=>i<1||c[i-1]<=v));
}

이 경우 함수의 두 번째 줄은 위와 동일한 논리를 사용합니다. Select챙기고하여 목록의 요소와 그들에 변환합니다 int. ToList¹ 에 대한 호출 은 선택을 강제로 평가 하고 컴파일 타임에 var로 변환하여 정수 컬렉션에서 작동 List<int>하도록합니다 Where.

C # 패드에서 사용해보십시오

4 바이트와 5 바이트를 각각 트리밍하는 데 도움을 준 VisualMelon 덕분 입니다. :)

_{투투리스트 1 개?}

CJam, 15 바이트

q~{_2$<{;}&}*]p

CJam 통역사 에서 온라인으로 사용해보십시오 .

작동 원리

q~               Read an evaluate all input.
  {        }*    Reduce; push the first element; or each remaining element:
   _2$           Copy the topmost and second topmost element from the stack.
      <          Check if the topmost is smaller than the second topmost.
       {;}&      If it is, remove it from the stack.
             ]   Wrap the stack i an array.
              p  Print.

PowerShell , 32 바이트

$args|?{$e-eq$p-or$_-ge$p;$p=$_}

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

덜 골프 :

$args|?{
    $empty -eq $previous -or $_ -ge $previous
    $previous = $_
}

C : 73 바이트

int i,j;i=j=INT_MIN;while(scanf("%d",&j)!=EOF)if(j>=i)printf("%d",j),i=j;

또는

C : 49 바이트

( 코드 골프 대회를 위해 만들어진 세관 헤더 가 허용되는 경우)

I z,y;z=y=INT_MIN;w(s(D,&y)!=E)i(y>z)p(D,y),z=y;}

여전히 CJam을 이길 수는 없지만 적어도 다른 언어를 이길 수는 있습니다.

해 학적 인, 13 바이트

테스트 사례를 통과하는 11 바이트 솔루션 :

-.2CO:so)[~

여기에서 온라인으로 시도하십시오 .

설명:

-. -- prepend head of list to list
2CO -- n-grams (sliding window) of size 2
:so -- filter sorted lists
)[~ -- map last

그러나이 버전은 두 숫자 사이에 작은 숫자 두 개가 없다는 사실 만 사용하여 작동합니다. 그렇지 않으면 아래 버전 (13B)을 사용하십시오.

이전 버전 :

J-]{cm-1.>}LO

여기에서 온라인으로 시도하십시오. 설명:

J -- duplicate
-] -- head
{
  cm -- compare (returning -1,0 or 1)
  -1.> -- greater than -1
}LO -- Loop

같은 숫자를 삭제하면 .>대신을 사용할 수 cm있습니다. 또한 목록에 양수 만 포함 된 경우 0또는 -1대신 사용할 수 있습니다 J-].

Minkolang 0.9 , 18 바이트

ndN(nd1R`2&dN$I$).

여기에서 시도하십시오.

설명

ndN                Take first integer from input
(         $I$).    Repeat until the input is empty and then stop.
 nd1R`             Is the next integer less than the previous one?
      2&dN         If not (i.e., it's greater than or equal to), print it.

루비, 41 명

->a{m=a[0];a.map{|n|m>n ?p: m=n}-[p]}

샘플 실행 :

2.1.5 :001 > [
2.1.5 :002 >     [1, 2, 5, 4, 3, 7],
2.1.5 :003 >     [10, -1, 12],
2.1.5 :004 >     [-7, -8, -5, 0, -1, 1],
2.1.5 :005 >     [9, 8, 7, 6, 5],
2.1.5 :006 >     [10, 13, 17, 21],
2.1.5 :007 >     [10, 10, 10, 9, 10],
2.1.5 :008 > ].each{ |test| p ->a{m=a[0];a.map{|n|m>n ?p: m=n}-[p]}[test] }
[1, 2, 5, 7]
[10, 12]
[-7, -5, 0, 1]
[9]
[10, 13, 17, 21]
[10, 10, 10, 10]

NARS2000 APL, 13 바이트

NARS2000은 Windows 용 무료 APL 인터프리터입니다. 운영자가 액세스 하는 다중 세트 기능을 포함 합니다 ⍦.

(+⍦∩⌈\)

이것은 ⍦∩입력 ( +) * 의 다중 집합 교차점 ( ) *과 실행 최대 값 목록 ( ) 을 취하는 모나 딕 포크입니다 ⌈\.

⍦1 바이트 APL 레거시 인코딩에서는 표준 APL 문자가 아니기 때문에 UTF-8을 사용하여 ⍦∩⌈문자를 각각 3 바이트로 만들어야합니다. 두 바이트를 저장하는 +대신 선택했습니다 ⊢.

NARS2000은 괄호없이 열차에 내장 할 수있는 포크를 지원하지만 Dyalog와 달리 괄호로 묶지 않고 함수에 할당 할 수는 없습니다.

* +기술적으로 복잡한 켤레이지만 입력은 실제입니다.

-v 플래그를 가진 > <> , 36 31 + 2 = 33 바이트

:&\o " "&n:~& <
~ >l?!;:&:&(?!^

-v를 사용하여 스택의 목록을 입력하여 목록의 첫 번째 요소가 스택의 맨 위에 오도록하십시오. 후행 공백이있는 분류 된 목록을 인쇄합니다.

시운전 :

$ for input in "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"; do echo $input '-> ' $(python fish.py dropsort.fsh -v $(echo $input | tac -s ' ')); done

1 2 5 4 3 7 ->  1 2 5 7

10 -1 12 ->  10 12

-7 -8 -5 0 -1 1 ->  -7 -5 0 1

9 8 7 6 5 ->  9

10 13 17 21 ->  10 13 17 21

10 10 10 9 10 ->  10 10 10 10

편집 : Fongoid 덕분에 5 바이트 저장

파이썬 102 99 94 + 5 6 비 파일 최종 바꿈 = 107 105 100 바이트

(들여 쓰기에 탭을 사용했습니다)

def d(l):
    j=b=0;m=l[j];r=[]
    for i in l:
        (m,b)=[(m,0),(i,1)][i>=m]
        if b>0:r+=[i]
        j+=1
    l[:]=r

가장 좋은 것은 아니지만 이것은 코드 골프에서의 첫 번째 장면입니다. 제거 관련 버그가 발생하지 않고 목록을 인라인으로 정렬하는 방법을 알 수 없으므로 정렬 된 요소를 임시 목록으로 옮겼습니다.

편집 : list.append ()는 못생긴 방법보다 짧습니다.

r + = [i]는 list.append ()보다 짧았습니다. 감사합니다 njzk2 !

스칼라 : 232 126 120 바이트

def f(x:Int*)=(Seq[Int]()/:x)((r,y)=>r.headOption.filter(y>=).map(_=>y+:r).getOrElse(if(r.isEmpty) y+:r else r)).reverse

스칼라, 54 바이트

def f(x:Int*)=(x:\Seq[Int]())((y,r)=>y+:r.filter(y<=))

언 골프 드 :

def dropSort(xs: Seq[Int]): Seq[Int] =
  xs.foldRight(Seq.empty[Int]) { (x, result) =>
    x +: result.filter(r => r >= x)
  }

작은 리스프, 107 바이트

( 이 언어는 단지 출판 되었음 이 질문 후, 그래서이 답변이 경쟁에서 실행됩니다.이 승리 할 기회가 없었있다. 언어가 나중에 내가 여기에 사용 된 것보다 더 buildins을 가지고 더 진화,하지만 난과 함께있을거야 버전은 원래는 2015 년에 구현 이 대답은 여전히 새로운 공식 통역사와 함께 작동 내가 매개 변수 정의하기 때문에 몇 가지 경고를 제공하지만, 새로운 buildin 그림자 (추가하는). _{산화 티타늄 링크에 대한 DLosc에 감사합니다.} )aa

(d r(q((m a)(i a(i(l(h a)m)(r m(t a))(c(h a)(r(h a)(t a))))()))))(d ds(q((b)(i b(c(h b)(r(h b)(t b)))()))))

이것은 인수를 정렬 하는 함수 ds(및 재귀 도우미 함수 r)를 정의하며 정수 목록이어야합니다.

r 꼬리 재귀 함수가 아니므로 매우 긴 목록의 경우 스택 오버플로가 발생할 수 있습니다.

언 골프 드 :

(d r
   (q((m a)
      (i a
         (i (l (h a) m)
            (r m (t a))
            (c (h a)
               (r (h a) (t a))
             )
          )
         ()
       )
   ) )
 )
(d ds
  (q(
      (b)
      (i b
        (c (h b)
           (r (h b) (t b))
         )
        ()
       )
   ) )
 )

다음은 이것을 사용하는 방법에 대한 몇 가지 예입니다 (문제의 테스트 사례와 함께).

(d list (q (args args)))
(d -
   (q( (n)
       (s 0 n)
    ) )
 ) 

(ds (list 1 2 5 4 3 7))
(ds (list 10 (- 1) 12))
(ds (list (- 7) (- 8) (- 5) 0 (- 1) 1))
(ds (list 9 8 7 6 5))
(ds (list 10 13 17 21))
(ds (list 10 10 10 9 10))

(예, -7정수 리터럴이 아니므로이를 나타내는 함수를 정의해야합니다.) 출력 :

list
-
(1 2 5 7)
(10 12)
(-7 -5 0 1)
(9)
(10 13 17 21)
(10 10 10 10)

젤리, 5 바이트

=»\Tị

도전은 젤리의 생성보다 우선합니다.

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

작동 원리

=»\Tị  Main link. Argument: A (list)

 »\    Yield the cumulative maxima of A.
=      Perform element-by-element comparison.
       Yields 1 iff A[n] = max(A[1], ..., A[n]).
   T   Get all indices of truthy elements.
    ị  Retrieve the items of A at those indices.

수학, 27 바이트

Pick[#,#-Max~FoldList~#,0]&