Thách thức này đã mô tả giọt nước. Tuy nhiên, tôi hơi lười biếng và tôi thực sự chỉ cần mảng của mình được sắp xếp nhiều hơn một chút so với trước đây, nó không cần phải được sắp xếp theo mọi cách .

Trong Drop Sort, chúng tôi thả mọi phần tử ít hơn bất kỳ phần tử nào trước nó. Trong Lazy Drop Sort, chúng tôi bỏ mọi phần tử ít hơn phần tử trước nó.

Đây là một ví dụ. Hãy xem xét các mảng sau:

8 6 9 9 7 2 3 8 1 3

Hãy đánh dấu mọi yếu tố ít hơn yếu tố trước nó.

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

Chú ý cách không 3được đánh dấu, cũng không phải cuối cùng 8. Chúng đều lớn hơn phần tử đơn ở bên trái của chúng.

Hoàn thành thuật toán, loại bỏ các yếu tố được đánh dấu, chúng tôi nhận được:

8 9 9 3 8 3

Điều đó về cơ bản trông sắp xếp hơn. Kinda. Tôi lười.

Nhiệm vụ của bạn, như bạn có thể đã suy ra, là thực hiện thuật toán này.

Đầu vào là một mảng có ít nhất 1 số nguyên dương trong khoảng từ 1 đến 9, vì vậy bạn cũng có thể lấy một chuỗi các chữ số.

Đây là mã golf , ít byte thắng nhất!

Các trường hợp kiểm tra bổ sung:

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

Husk , 4 byte

m←ġ<

Hãy thử trực tuyến!

Giải trình

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

JavaScript (ES6), 28 25 byte

Đã lưu 3 byte nhờ @Shaggy

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

Hãy thử trực tuyến!

R , 27 byte

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

Hãy thử trực tuyến!

MATL , 9 8 byte

Đã lưu một byte nhờ Giuseppe.

0yd0<h~)

Hãy thử trực tuyến!

Giải trình:

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 byte

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

Hãy thử trực tuyến!

Haskell, 29 byte

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

chỉ là một sự hiểu biết danh sách đơn giản.

Japt , 8 7 byte

Đã lưu 1 byte nhờ @Oliver

k@>(U=X

Kiểm tra nó trực tuyến!

Lựa chọn thay thế:

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

Stax , 5 byte

âÿ╠╦░

Chạy và gỡ lỗi này trực tuyến

Giải nén, giải mã và nhận xét mã, chúng tôi nhận được điều này.

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

Chạy cái này

Việc sắp xếp các hướng dẫn là khó xử nhưng có một lý do cho nó. Đóng gói mã nguồn không phải lúc nào cũng mang lại đầu ra kích thước giống nhau cho đầu vào cùng kích thước. Về cơ bản, bạn có cơ hội lưu một byte nếu ký tự cuối cùng của nguồn có mã ký tự thấp hơn. Chà, !có một trong những mã thấp nhất bạn có thể nhận được cho một ký tự có thể in được. (33 cụ thể) Nhiều chương trình stax ASCII 6 byte không thể đóng gói nhỏ hơn. Nhưng nếu họ kết thúc bằng một !, thì họ có thể. Vì vậy, lý do cho thứ tự hướng dẫn cụ thể này là để đảm bảo rằng logic không kết thúc vào cuối chương trình.

J, 12 byte

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

Giải trình:

#~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

Ví dụ:

    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

Hãy thử trực tuyến!

Thạch , 6 byte

>Ɲ0;¬×

I / O là trên chuỗi.

Hãy thử trực tuyến!

Java 8, 66 55 48 byte

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

-11 byte sau một mẹo từ @ OlivierGrégoire .
-7 byte nhiều hơn nhờ @ OlivierGrégoire .

Giải trình:

Hãy thử trực tuyến.

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

Octave , 21 byte

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

Hãy thử trực tuyến!

Giải trình:

Lấy một vectơ xlàm đầu vào và tạo một vectơ [0, diff(x)<0], trong đó diff(x)một vectơ có sự khác biệt giữa tất cả các phần tử liền kề. Chỉ giữ lại những số âm bằng cách so sánh nó với 0, cung cấp cho chúng tôi danh sách tất cả các yếu tố chúng tôi muốn loại bỏ.

Sau đó chúng tôi chọn các phần tử từ vector đầu vào mà chúng tôi muốn giữ.

V , 25 byte

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

Hãy thử trực tuyến!

Hexdump:

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

Ngôn ngữ tồi tệ nhất cho công việc. Nhưng tôi đã làm điều đó cho một dám .

Hình tam giác , 71 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động?

) Classified) rFD) 2+) IE) w + h) 2_stDO = {M) IEm} - Chương trình đầy đủ.
) IE - Nhận đầu vào thứ 0 và đánh giá nó.
   L) r - Và đẩy phạm vi [0 ... chiều dài của I).
      F {- Lọc các số nguyên trong phạm vi này thỏa mãn:
       D) 2+) IE) w + h) 2_stDO = - Điều kiện này. Chạy từng phần tử E trên một riêng biệt
                                    xếp chồng và loại bỏ những thứ không đáp ứng tiêu chí.
       D) 2+ - Sao y và thêm 2 vào bản sao thứ hai.
           ) IE - Truy xuất tôi một lần nữa.
              ) - Đẩy 0 lên ngăn xếp.
               w - Gói 0 trong danh sách. [0]
                + - Chuẩn bị nó cho tôi.
                 h - Đầu. Cắt các phần tử sau chỉ số E + 2.
                  ) 2_ - Nghĩa đen -2.
                     st - Đuôi.
                       DO = - Kiểm tra xem kết quả có bất biến khi sắp xếp không.
                           M) IEm} - Phần cuối: lập chỉ mục vào đầu vào.
                           M} - Đối với mỗi chỉ số thỏa mãn các điều kiện:
                            ) IEm - Lấy phần tử của I tại vị trí đó.

Python , 40 byte

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

Hãy thử trực tuyến!

Nhập vào dưới dạng bộ ký tự.

Python 3 , 41 byte

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

Hãy thử trực tuyến!

Chuỗi đầu vào.

Python 2 , 41 byte

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

Hãy thử trực tuyến!

Nhập chuỗi, chỉ vì chuỗi lớn hơn idnhưng số nhỏ hơn.

Ngôn ngữ Wolfram (Mathicala) , 33 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Mã # - {0}~Join~Most@#biến một mảng {a,b,c,d,e,f}thành {a,b-a,c-b,d-c,e-d,f-e}. Áp dụng Argcho điều này đặt các số âm thành Pivà số không âm cho 0.

Pick[#, ..., 0]&chọn ra các mục trong #đó ...có một 0: trong trường hợp của chúng tôi, chính xác các phần tử mang lại một số không âm khi bạn trừ phần tử trước đó. Nói cách khác, đây chính xác là những mục chúng tôi muốn giữ khi lazydropsorting.

Kỳ quan , 27 byte

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

Ví dụ sử dụng:

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

Giải trình

Phiên bản bị đánh cắp:

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

Chuẩn bị 0, nhận danh sách các cặp liên tiếp, giữ danh sách các mục trong đó số thứ nhất <= số thứ hai, nhận số thứ hai của mỗi cặp.

Ngôn ngữ Wolfram (Mathicala) , 20 byte

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

Hãy thử trực tuyến!

Giải trình

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

Split[#,##>0&]

Nhóm yếu tố liên tiếp được giải mã nghiêm ngặt: {{8, 6}, {9}, {9, 7, 2}, {3}, {8, 1}, {3}}

#&@@@

Lấy yếu tố đầu tiên của mỗi: {8, 9, 9, 3, 8, 3}

Python 2 , 52 46 45 42 byte

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

Hãy thử trực tuyến!

Đã lưu:

• -3 byte, nhờ có Rod

SWI-Prolog, 44 byte

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

Cách sử dụng: Gọi " Danh sách -X" trong đó Danh sách là danh sách được bao quanh bằng dấu phẩy, được phân tách bằng dấu phẩy, ví dụ [1,4,5,1,11,6,7].

APL + THẮNG, 14 byte

Nhắc nhở đầu vào màn hình của một vectơ số nguyên.

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

05AB1E , 6 byte

ĆÁü›_Ï

Hãy thử trực tuyến!

Giải trình

Ć        # 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

Kotlin , 39 byte

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

Hãy thử trực tuyến!

Các mục lọc là mục đầu tiên (index == 0 hoặc thậm chí chỉ mục ngắn hơn <1) HOẶC Giá trị hiện tại lớn hơn hoặc bằng mục trước (a [i-1]).

APL (Dyalog Unicode) , 11 byte

{⍵⌿⍨1⍪2≤⌿⍵}

Hãy thử trực tuyến!

Điều này thực sự khá giống với câu trả lời của Graham, nhưng ở Dyalog, và được phát triển độc lập. Ngoài ra, đối xứng hơn.

K4 , 10 byte

Dung dịch:

x_/|&<':x:

Thí dụ:

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

Giải trình:

Tìm các chỉ mục có phần tử nhỏ hơn trước, loại bỏ các chỉ mục này khỏi đầu vào

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

Tùy viên , 24 byte

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

Hãy thử trực tuyến!

Giải trình

Maskchọn tất cả các phần tử từ đối số thứ hai tương ứng với các phần tử trung thực trong đối số thứ nhất. 1'(Delta!_>=0)tính toán các chỉ số tương ứng với các phần tử được cho là nằm trong mảng cuối cùng.

Những nỗ lực khác

28 byte (không có điểm): ~Mask#(1&`'##Delta#`>=#C[0])

32 byte: {Mask[1'(&`<= =>Slices[_,2]),_]}

C # (.NET Core) , 33 + 18 = 51byte

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

Hãy thử trực tuyến!

về cơ bản câu lệnh là trong đó x là int đầu tiên trong mảng hoặc lớn hơn hoặc bằng số trước đó, hãy giữ nó. Khác bỏ nó.

Swift 4 , 56 55 byte

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

Hãy thử trực tuyến!

Giải trình

{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

Thạch , 9 byte

0;>ƝżµḢÐṂ

Hãy thử trực tuyến!

Điều này cảm thấy khá cồng kềnh, sẽ không ngạc nhiên nếu có một cách tốt hơn.

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

Brain-Flak , 136 , 120 byte

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

Ở đây nó được định dạng và "có thể đọc được" .

((()))
{
    {}

    ([{}]({}))

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

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

    {}

    ([][()])

}{}{}<>

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

Hãy thử trực tuyến!