Цей виклик уже описує дрозорт. Однак я ніби лінивий, і мені справді потрібен лише мій масив, щоб бути трохи більш відсортованим, ніж раніше, його не потрібно сортувати весь шлях .

У Drop Sort ми скидаємо кожен елемент менше, ніж будь-який елемент перед ним. У режимі "Ледачий сортування" ми скидаємо кожен елемент менше, ніж той, який суворо передує йому.

Ось приклад. Розглянемо наступний масив:

8 6 9 9 7 2 3 8 1 3

Позначимо кожен елемент менше, ніж один перед ним.

8 6 9 9 7 2 3 8 1 3
  ^     ^ ^     ^

Зверніть увагу, як ні 3відмічено, ні останнє 8. Всі вони більше, ніж одиничний елемент зліва від них.

Виконуючи алгоритм, видаляючи позначені елементи, отримуємо:

8 9 9 3 8 3

Це в основному виглядає більш відсортованим. Свого роду. Я ледачий.

Ваше завдання, як ви, можливо, вже зробили, - реалізувати цей алгоритм.

Введення - це масив щонайменше з 1 додатного цілого числа між 1 і 9, тому ви також можете взяти рядок цифр.

Це кодовий гольф , найменше виграш байтів!

Додаткові тестові випадки:

1
1

1 2 3
1 2 3

5 3 1
5

1 2 3 2 1
1 2 3

1 1 1 9 9 9 1 1 1 9 9 9 1 1 1
1 1 1 9 9 9 1 1 9 9 9 1 1

9 9
9 9

5 2 4 2 3
5 4 3

Лушпиння , 4 байти

m←ġ<

Спробуйте в Інтернеті!

Пояснення

m←ġ<
  ġ<    Group the numbers into decreasing sequences
m←      Keep the first element of each sequence

JavaScript (ES6), 28 25 байт

Збережено 3 байти завдяки @Shaggy

a=>a.filter(n=>~-a<(a=n))

Спробуйте в Інтернеті!

R , 27 байт

(l=scan())[c(T,diff(l)>=0)]

Спробуйте в Інтернеті!

MATL , 9 8 байт

Збережено один байт завдяки Джузеппе.

0yd0<h~)

Спробуйте в Інтернеті!

Пояснення:

0                 % Push a zero
 y                % Implicitly grab the input and duplicate it.
                  % Stack: [8 6 9 9 7 2 3 8 1 3], 0, [8 6 9 9 7 2 3 8 1 3]
  d               % The difference between each number of the last element:
                  % Stack: [8 6 9 9 7 2 3 8 1 3], 0, [-2, 3, 0, -2, -5, 1, 5, -7, 2]
   0<             % Which are negative?
                  % Stack: [8 6 9 9 7 2 3 8 1 3], 0, [1 0 0 1 1 0 0 1 0]
     h            % Concatenate. Stack: [8 6 9 9 7 2 3 8 1 3], [0 1 0 0 1 1 0 0 1 0] 
      ~           % Negate. Stack: [8 6 9 9 7 2 3 8 1 3], [1 0 1 1 0 0 1 1 0 1]
       )          % Index. Stack: [8 9 9 3 8 3]

Perl 5 .10.0 + -nl, 16 байт

$f>$_||say;$f=$_

Спробуйте в Інтернеті!

Хаскелл, 29 байт

f s=[b|(a,b)<-zip(0:s)s,a<=b]

просто просте розуміння списку.

Japt , 8 7 байт

Збережено 1 байт завдяки @Oliver

k@>(U=X

Перевірте це в Інтернеті!

Альтернативи:

f@T§(T=X
k@ä>0 gY
i0 ò> mÅ c

Стакс , 5 байт

âÿ╠╦░

Запустити та налагодити це в Інтернеті

Розпаковуючи, скасовуючи та коментуючи код, ми отримуємо це.

Z   Push a zero under the input
f   Use the rest of the program as a filter on the input.  Output passing elements.
>   Current element is greater than previous?
_~  Push current element to the input stack; when the main stack is empty, pops fall back to this
!   Logical not; applies to the result of the greater-than

Виконати цей

Упорядкування інструкцій незручне, але в цьому є причина. Упаковка вихідного коду Stax не завжди дає вихід однакового розміру для одного і того ж розміру. В основному, у вас є шанс зберегти байт, якщо останній символ джерела має менший код символів. Ну, !є один з найнижчих кодів, який можна отримати для друку. (33 конкретно) Багато 6-байтних програм ASCII Stax не можуть спакувати менші розміри. Але якщо вони закінчуються символом a !, вони можуть. Отже, причиною цього конкретного впорядкування інструкцій є те, щоб логічне не закінчилося в кінці програми.

J, 12 байт

#~1,2&(<:/\)

Пояснення:

#~1,2&(<:/\)    | Whole function, executed as a hook
       <:/      | Distribute <: (greater or equal) over an array
    2&(   \)    | Apply to each sub array of length 2
  1,            | Append a 1 to the front
#~              | Choose elements from the original array

Приклади:

    2&(<:/\) 8 6 9 9 7 2 3 8 1 3
0 1 1 0 0 1 1 0 1
    1,2&(<:/\) 8 6 9 9 7 2 3 8 1 3
1 0 1 1 0 0 1 1 0 1
    (1 0 1 1 0 0 1 1 0 1) # 8 6 9 9 7 2 3 8 1 3
8 9 9 3 8 3
    f =: #~1,2&(<:/\)
    f 8 6 9 9 7 2 3 8 1 3
8 9 9 3 8 3

Спробуйте в Інтернеті!

Желе , 6 байт

>Ɲ0;¬×

Введення / виведення є на рядках.

Спробуйте в Інтернеті!

Ява 8, 66 55 48 байт

l->{for(int i=0;;)if(i>(i=l.next()))l.remove();}

-11 байт після підказки від @ OlivierGrégoire .
-7 більше байт завдяки @ OlivierGrégoire .

Пояснення:

Спробуйте в Інтернеті.

l->{                     // Method with Integer-ListIterator parameter and no return-type
  for(int i=0;;)         //  Loop over all items
    if(i>(i=l.next()))   //   If the current item is larger than the next
      l.remove();}       //    Remove this next item

Октава , 21 байт

@(x)x(~[0,diff(x)<0])

Спробуйте в Інтернеті!

Пояснення:

Візьміть вектор xяк вхідний і створіть вектор [0, diff(x)<0], деdiff(x) вектор з різницею між усіма сусідніми елементами. Зберігайте лише ті негативні, порівнюючи їх до нуля, подаючи нам список усіх елементів, які ми хочемо скинути.

Потім вибираємо елементи з вхідного вектора, який ми хочемо зберегти.

V , 25 байт

òjälá k$yl+@"òç-/d
ç /dw

Спробуйте в Інтернеті!

Hexdump:

00000000: f26a e46c e120 6b24 796c 2b40 2218 f2e7  .j.l. k$yl+@"...
00000010: 2d2f 640a e720 2f64 77                   -/d.. /dw

Найгірша мова для роботи. Але я це зробив на сміливість .

Трикутність , 71 байт

.....).....
....IEL....
...)rFD)...
..2+)IE)w..
.+h)2_stDO.
={M)IEm}...

Спробуйте в Інтернеті!

Як це працює?

) IEL) rFD) 2+) IE) w + h) 2_stDO = {M) IEm} - Повна програма.
) IE - Отримайте 0-й вхід I і оцініть його.
   L) r - І натисніть на діапазон [0 ... довжина I).
      F {- Фільтр цілих чисел у цьому діапазоні, які задовольняють:
       Г) 2+) IE) w + h) 2_stDO = - Ця умова. Запускає кожен елемент Е окремо
                                    складати та відкидати ті, які не відповідають критеріям.
       D) 2+ - Скопіюйте та додайте 2 до другого примірника.
           ) IE - Отримати знову.
              ) - Натисніть 0 на стек.
               w - Загорніть 0 у список. [0]
                + - Додайте його до я.
                 h - Голова. Обріжте елементи після індексу Е + 2.
                  ) 2_ - Буквальний -2.
                     st - Хвіст.
                       DO = - Перевірте, чи результат інваріантний щодо сортування.
                           М) IEm} - Остання частина: індексація на вхід.
                           M} - для кожного індексу, який відповідає умовам:
                            ) IEm - витягніть елемент I у цій позиції.

Пітон , 40 байт

f=lambda h,*t:t and h+f(*t)[h>t[0]:]or h

Спробуйте в Інтернеті!

Введіть як кортеж символів.

Python 3 , 41 байт

p=''
for x in input():x<p or print(x);p=x

Спробуйте в Інтернеті!

Рядок введення.

Python 2 , 41 байт

for x in input():
 if x>=id:print x
 id=x

Спробуйте в Інтернеті!

Введення рядків, лише тому, що рядків більше, ніж id але число менше.

Мова Вольфрама (Mathematica) , 33 байти

Pick[#,Arg[#-{0}~Join~Most@#],0]&

Спробуйте в Інтернеті!

Як це працює

Код # - {0}~Join~Most@#перетворює масив {a,b,c,d,e,f}у {a,b-a,c-b,d-c,e-d,f-e}. Застосовуючи Argдо цього, встановлюється від'ємні числа до, Piа невід'ємні числа - 0.

Pick[#, ..., 0]&вибирає записи, #де ...є 0: у нашому випадку - саме ті елементи, які дають негативне число, коли ви віднімаєте попередній елемент. Іншими словами, це саме записи, які ми хочемо зберегти під час ліниводства.

Диво , 27 байт

-> ':1.!> 'sS#<=.cns2.++[0]

Приклад використання:

(-> ':1.!> 'sS#<=.cns2.++[0])[8 6 9 9 7 2 3 8 1 3]

Пояснення

Безгольова версія:

(map get 1).(fltr sS <=).(cns 2).(++ [0])

Попередньо 0, отримати список послідовних пар, зберегти елементи списку, де перше число <= друге число, отримати друге число кожної пари.

Мова Вольфрама (Mathematica) , 20 байт

#&@@@Split[#,##>0&]&
(* or *)
Max/@Split[#,##>0&]&

Спробуйте в Інтернеті!

Пояснення

Input = {8, 6, 9, 9, 7, 2, 3, 8, 1, 3}

Split[#,##>0&]

Групуйте послідовні елементи, які суворо зменшуються: {{8, 6}, {9}, {9, 7, 2}, {3}, {8, 1}, {3}}

#&@@@

Візьміть перший елемент кожного: {8, 9, 9, 3, 8, 3}

Python 2 , 52 46 45 42 байт

lambda a:[v for v,w in zip(a,[1]+a)if v/w]

Спробуйте в Інтернеті!

Збережено:

• -3 байти, завдяки Роду

SWI-Prolog, 44 байти

[A,B|C]-[A|E]:-B<A,[B|C]-[B|E];[B|C]-E. L-L.

Використання: виклик " Список -X", де Список - це скоплений дужкою список, розділений комами, наприклад [1,4,5,1,11,6,7].

APL + WIN, 14 байт

Підказки для введення екрану вектора цілих чисел.

(1,1>2-/v)/v←⎕

05AB1E , 6 байт

ĆÁü›_Ï

Спробуйте в Інтернеті!

Пояснення

Ć        # append the head of the list
 Á       # rotate right
  ü›     # apply pair-wise greater-than
    _    # logical negate each
     Ï   # keep elements of input that are true in this list

Котлін , 39 байт

a->a.filterIndexed{i,v->i<1||v>=a[i-1]}

Спробуйте в Інтернеті!

Фільтруйте елементи, які є першим елементом (індекс == 0, або навіть коротший індекс <1) АБО поточне значення більше або дорівнює попередньому елементу (a [i-1]).

APL (Dyalog Unicode) , 11 байт

{⍵⌿⍨1⍪2≤⌿⍵}

Спробуйте в Інтернеті!

Це насправді досить схоже на відповідь Грема, але в «Діялогу» і незалежно розроблено. Також більш симетричні.

К4 , 10 байт

Рішення:

x_/|&<':x:

Приклад:

q)k)x_/|&<':x:8 6 9 9 7 2 3 8 1 3
8 9 9 3 8 3

Пояснення:

Знайдіть індекси, де елемент менше попереднього, видаліть ці індекси з вхідних даних

x_/|&<':x: / the solution
        x: / store input as x
     <':   / less-than each-previous
    &      / indices where true
   |       / reverse
 _/        / drop-over
x          / the input

Attache , 24 байти

{Mask[1'(Delta!_>=0),_]}

Спробуйте в Інтернеті!

Пояснення

Maskвибирає всі елементи зі свого другого аргументу, які відповідають правдивим елементам у першому аргументі. 1'(Delta!_>=0)обчислює індекси, які відповідають елементам, які повинні бути в кінцевому масиві.

Інші спроби

28 байт (pointfree): ~Mask#(1&`'##Delta#`>=#C[0])

32 байти: {Mask[1'(&`<= =>Slices[_,2]),_]}

C # (.NET Core) , 33 + 18 = 51 байт

x=>x.Where((a,n)=>n<1||x[n-1]<=a)

Спробуйте в Інтернеті!

в основному висловлювання полягає в тому, де x - перший int в масиві, або більше або дорівнює попередньому номеру, зберігайте його. Інше киньте його.

Швидкий 4 , 56 55 байт

{var l=0;print($0.filter{($0>=l,l=$0).0})}as([Int])->()

Спробуйте в Інтернеті!

Пояснення

{var l=0;           // Declare variable l
print($0.filter{(   // Print every element e in the input
  $0>=l,            //   where e >= l
  l=$0).0})         //   And set l to e
}as([Int])->()      // Set the input type to integer array

Желе , 9 байт

0;>ƝżµḢÐṂ

Спробуйте в Інтернеті!

Це відчуває себе досить об'ємно, не здивувало б, якщо є кращий спосіб.

0;>ƝżµḢÐṂ
   Ɲ       For each adjacent pair in the input...
  >        ...is the first element greater than the second? (yields a list of 0/1)
0;         prepend a zero to this list (always keep the first element)
    ż      zip with the input
     µ     new monadic link
       ÐṂ  keep elements of the list with minimal value of... (Ðḟ would have worked here and been slightly more clear but I'll leave it as it is)
      Ḣ    ...their first element

Мозг-Флак , 136 , 120 байт

((())){{}([{}]({}))([({}<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}{{}(({})<>)(())(<>)}{}([][()])}{}{}<>{{}({}<>)<>}<>

Тут він відформатований і "читабельний" .

((()))
{
    {}

    ([{}]({}))

    ([({}<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}

    {
        {}(({})<>)(())(<>)
    }

    {}

    ([][()])

}{}{}<>

{
    {}
    ({}<>)<>
}<>

Спробуйте в Інтернеті!