由David Morgan-Mar设计的Dropsort是线性时间“排序算法”的一个示例，该算法可以生成实际上是已排序但仅包含某些原始元素的列表。任何不小于其最大元素数量的元素都将从列表中删除并丢弃。

在此任务中，将为您提供一个整数列表作为输入（STDIN或函数参数，要求您至少支持8位有符号整数的范围。）您的任务是对它们进行dropsort，然后将剩余的元素输出到订购。

您可以假定列表为非空。

这是代码高尔夫，所以最短的程序会获胜。

测试用例

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个字节

⊢(/⍨)⊢=⌈\

这是带图的单子函数训练：

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

非火车版本是

{⍵/⍨⍵=⌈\⍵}

这基本上检查每个元素是否等于运行的最大值。

请注意，马丁·布特纳（MartinBü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<)。

Python 2，49

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

JavaScript（ES6），29

滥用javascript中的标准类型转换，将数组转换为数字：

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

这是一种罕见的情况：我使用的算法（据我所知可以快速浏览一下）到目前为止还没有人使用，并且它以某种不同的语法和内置集，程序之间具有1对1的对应关系（命令甚至以相同的顺序！）。因此，将它们组合在一起似乎更有意义-从某种意义上说，它们是同一程序，我用两种语言编写它以查看哪种格式更短-而不是分别提交它们。

这里的基本思想是，列表的dropsort是其子序列，按字典顺序为最大反向。奇怪的是，Brachylog和Jelly都没有内置函数可通过特定函数查找最大值（Jelly具有内置函数可通过特定函数返回所有最大值，但这将返回包含结果而不是结果本身的单例列表，并且还不比以这种方式做的短。因此，我们生成所有可能的子序列，按逆序排序，取最后一个。

“按字典顺序排列的最大反向”起作用的原因是，所选输出必须以输入列表中的最高编号结束（因此其反向必须开始）（很容易看到dropsort输出将始终以此结尾），因此可以之后不包含任何内容（因为采用子序列可以保留顺序）。归纳重复，最后得到dropsort的定义。

Mathematica，26个字节

DeleteDuplicates[#,#>#2&]&

R，29 26字节

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

这将创建一个函数对象，该对象接受一个向量，x并x在除去所有不小于的累积最大值的元素后返回x。

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

Java，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并比较每个元素。

Perl，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

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

Haskell，38 37字节

使用JArkinstall节省了1个字节。

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

C＃ - 6864或 132127个字符

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

Where在这种情况下，将遍历列表，并为列表v中索引处的每个元素i评估布尔表达式。如果表达式的计算结果为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^1将强制对select求值，并在编译时将其var转换为a List<int>，以便Where对整数集合进行操作。

在C＃Pad上尝试

感谢VisualMelon分别帮助修剪4个字节和5个字节。:)

_{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岁 37个字符

->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解释器；它包括由操作员访问的多功能⍦。

(+⍦∩⌈\)

这是一个单子叉，它采用⍦∩输入（+）* 的多集交集（）和运行最大值列表（⌈\）。

由于⍦在一字节APL传统编码中不是标准APL字符，因此我们必须使用UTF-8，使⍦∩⌈每个字符三个字节。我选择+了⊢保存两个字节。

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个字节

Python，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

Scala，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)
  }

Tiny Lisp，107个字节

（此语言仅在此问题之后发布，因此该答案已失去竞争。并不是说它有任何获胜的机会。该语言后来发展得比我在此使用的内建函数更多，但我坚持使用版本我原来是在2015年实现这个答案仍然与新的官方解释工作，但它给出了一些警告，因为我定义的参数a，其阴影新的buildin a（添加）。_{对于TIO链接感谢DLosc。} ）

(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ị

请注意，挑战要早于创建Jelly。

在线尝试！

这个怎么运作

=»\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.

Mathematica，27个字节

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