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

Leaderboard

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

⊢(/⍨)⊢=⌈\

Это монадическая последовательность функций со схемой:

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

Версия без поезда

{⍵/⍨⍵=⌈\⍵}

Это в основном проверяет, равен ли каждый элемент рабочему максимуму.

Обратите внимание, что 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)

Итеративно переведенный, мы перебираем элементы, и для каждого видимого мы удаляем те, которые меньше его, из остальной части списка, который мы перебираем. Спасибо Антисфену за сохраненный байт (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.

Брахилог , 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 (команды даже в том же порядке!). Таким образом, казалось, что было бы более целесообразно объединить их - в некотором смысле, это одна и та же программа, и я написал ее на обоих языках, чтобы увидеть, какой из них был короче, - чем представлять их отдельно.

Основная идея здесь заключается в том, что дропсорт списка - это его подпоследовательность с лексикографически максимальным обратным. Как ни странно, ни Brachylog, ни Jelly не имеют встроенной функции для поиска максимума по определенной функции (Jelly имеет встроенную функцию, которая возвращает все максимумы по определенной функции, но при этом возвращался бы одноэлементный список, содержащий результат, а не сам результат, и и даже не короче, чем делать это так). Таким образом, вместо этого мы генерируем все возможные подпоследовательности, сортируем по обратному, принимаем последнее.

Причина, по которой работает «лексикографически максимальное обратное направление», заключается в том, что выбранный выход должен заканчиваться (поэтому его обратный ход должен начинаться) с наибольшего числа в списке входных данных (легко видеть, что выход с дропсортированием всегда будет заканчиваться этим), и, таким образом, может ничего после этого не содержит (потому что принятие подпоследовательностей сохраняет порядок). Повторите индуктивно, и мы получим определение DropSort.

Mathematica, 26 байт

DeleteDuplicates[#,#>#2&]&

R, 29 26 байт

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

Это создает функциональный объект, который принимает вектор xи возвращает xпосле удаления все элементы, по крайней мере, такие же, как кумулятивный максимум x.

Сохранено 3 байта благодаря flodel!

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

Сохранено 1 байт благодаря JArkinstall .

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исключение и сохраняет первый элемент в списке.

Если входные и выходные данные должны быть строками (я не могу сказать наверняка, поэтому я оставлю это на усмотрение ОП, а остальным вам решать).

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в 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либо .-1J-]

Минколанг 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 - бесплатный интерпретатор APL для Windows; он включает в себя функции мультимножества, доступные ⍦оператору.

(+⍦∩⌈\)

Это монадическая ветвь, которая принимает многосетевое пересечение ( ⍦∩) для input ( +) * и список работающих максимумов ( ⌈\).

Поскольку ⍦это не стандартный символ 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

Редактировать: 5 байтов сохранено благодаря Fongoid

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 !

Scala: 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<=))

Ungolfed:

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

Крошечный Лисп, 107 байт

( Этот язык был опубликован только после того, как этот вопрос, так что этот ответ работает вне конкуренции. Не то , чтобы он имел все шансы на победу. Язык позже эволюционировали дальше , чтобы иметь больше buildins , чем те , которые я использовал здесь, но я остаюсь с версия, которую я первоначально реализовал в 2015 году. Этот ответ по-прежнему работает с более новым официальным интерпретатором , хотя он дает некоторые предупреждения, потому что я определяю параметр, который скрывает новое построение (для добавления). _{Спасибо DLosc за ссылку TIO.} )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 не является хвостовой рекурсивной функцией, поэтому для очень длинных списков это может привести к переполнению стека.

Ungolfed:

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

Mathematica, 27 байт

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