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

⊢(/⍨)⊢=⌈\

Це поїзд монадичної функції зі схемою:

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

Версія без поїзда є

{⍵/⍨⍵=⌈\⍵}

Це, в основному, перевіряє, чи кожен елемент дорівнює максимуму, що працює.

Зауважте, що рішення 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<).

Пітон 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 (команди навіть в одному порядку!). Тому здавалося, що є більше сенсу поєднувати їх - певним чином, це одна і та ж програма, і я написав її на обох мовах, щоб побачити, яка коротша - ніж подавати їх окремо.

Основна ідея тут полягає в тому, що крапка списку - це її підпорядкування лексикографічно максимальним зворотом. Як не дивно, ні Брахілог, ні Jelly не мають вбудованого, щоб знайти максимум за певною функцією (Jelly має вбудований модуль, щоб повернути всі максимуми певною функцією, але це поверне однодисковий список, що містить результат, а не сам результат, і також не коротше, ніж робити це таким чином). Тож натомість ми генеруємо всі можливі послідовності, сортуємо за зворотом, беремо останню.

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

Математика, 26 байт

DeleteDuplicates[#,#>#2&]&

R, 29 26 байт

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

Це створює об’єкт функції, який приймає вектор xі повертається xпісля вилучення всіх елементів, щонайменше таких великих, як сукупний максимум x.

Збережено 3 байти завдяки флоделю!

К, 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

Пітон 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списку, оцінює булевий вираз. Якщо вираз оцінюється як істинне, то елемент додається до результату. Єдиний справжній хитрість булевого виразу - це коротке замикання на 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в 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-].

Міньколанг 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; він включає в себе функції мультисетів, до яких звертається ⍦оператор.

(+⍦∩⌈\)

Це монадична вилка, яка приймає перетин перетину ( ⍦∩) входу ( +) * та список максимумів, що працюють ⌈\.

Оскільки ⍦не є стандартним символом 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

Не найкраще там, але це мій перший вистріл у коді гольфу. Не вдалося розібрати спосіб сортування списку вбудованого, не натрапивши на помилки, пов’язані з видаленням, тому я перемістив упорядковані елементи у тимчасовий список.

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

Безголівки:

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 не є рекурсивною функцією хвоста, тому для дуже довгих списків це може стикатися з переповненням стека.

Безголівки:

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

Математика, 27 байт

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