Thuật toán sắp xếp như sau:

Trong khi danh sách không được sắp xếp, hãy chụp một nửa tất cả các mục (xóa chúng khỏi danh sách). Tiếp tục cho đến khi danh sách được sắp xếp hoặc chỉ còn một mục (được sắp xếp theo mặc định). Thuật toán sắp xếp này có thể cho kết quả khác nhau dựa trên việc thực hiện.

Quy trình loại bỏ vật phẩm tùy thuộc vào việc thực hiện để quyết định, nhưng danh sách nên dài hơn một nửa so với trước khi vượt qua quy trình loại bỏ vật phẩm. Thuật toán của bạn có thể quyết định xóa nửa đầu hoặc danh sách, nửa cuối của danh sách, tất cả các mục lẻ, tất cả các mục chẵn, mỗi lần một danh sách cho đến khi danh sách dài bằng một nửa hoặc bất kỳ mục nào không được đề cập.

Danh sách đầu vào có thể chứa một lượng vật phẩm tùy ý (theo lý do, giả sử có tới 1000 mặt hàng), không chỉ danh sách chia hết cho 2 ^ n mặt hàng. Bạn sẽ phải xóa (n + 1) / 2 hoặc (n-1) / 2 mục nếu danh sách là số lẻ, được mã hóa cứng hoặc được quyết định ngẫu nhiên trong thời gian chạy. Tự quyết định: Thanos sẽ làm gì nếu vũ trụ chứa một lượng sinh vật kỳ lạ?

Danh sách được sắp xếp nếu không có mục nào nhỏ hơn bất kỳ mục nào trước đó. Sự trùng lặp có thể xảy ra ở đầu vào và có thể xảy ra ở đầu ra.

Chương trình của bạn sẽ lấy một mảng các số nguyên (thông qua stdin hoặc dưới dạng tham số, các mục riêng lẻ hoặc tham số mảng) và trả về mảng đã sắp xếp (hoặc in nó ra thiết bị xuất chuẩn).

Ví dụ:

// A sorted list remains sorted
[1, 2, 3, 4, 5] -> [1, 2, 3, 4, 5]

// A list with duplicates may keep duplicates in the result
[1, 2, 3, 4, 3] -> [1, 3, 3] // Removing every second item
[1, 2, 3, 4, 3] -> [3, 4, 3] -> [4, 3] -> [3] // Removing the first half
[1, 2, 3, 4, 3] -> [1, 2] // Removing the last half

[1, 2, 4, 3, 5] có thể cho kết quả khác nhau:

// Removing every second item:
[1, 2, 4, 3, 5] -> [1, 4, 5]

hoặc là:

// Removing the first half of the list
[1, 2, 4, 3, 5] -> [3, 5] // With (n+1)/2 items removed
[1, 2, 4, 3, 5] -> [4, 3, 5] -> [3, 5] // With (n-1)/2 items removed

hoặc là:

// Removing the last half of the list
[1, 2, 4, 3, 5] -> [1, 2] // With (n+1)/2 items removed
[1, 2, 4, 3, 5] -> [1, 2, 4] // With (n-1)/2 items removed

hoặc là:

// Taking random items away until half (in this case (n-1)/2) of the items remain
[1, 2, 4, 3, 5] -> [1, 4, 3] -> [4, 3] -> [4]

R , 41 byte

x=scan();while(any(x-sort(x)))x=x[!0:1];x

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

Python 3 , 38 42 39 byte

q=lambda t:t>sorted(t)and q(t[::2])or t

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

-3 bytes cảm ơn @JoKing và @Quuxplusone

Python 2 , 39 byte

f=lambda l:l>sorted(l)and f(l[::2])or l

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

Brachylog (v2), 6 byte

≤₁|ḍt↰

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

Đây là một đệ trình chức năng. Đầu vào từ bên trái, đầu ra bên phải, như thường lệ. (Liên kết TIO sử dụng đối số dòng lệnh tự động bao hàm hàm thành một chương trình đầy đủ để bạn có thể thấy nó hoạt động.)

Giải trình

≤₁|ḍt↰
≤₁       Assert that {the input} is sorted {and output it}
  |      Handler for exceptions (e.g. assertion failures):
   ḍ     Split the list into two halves (as evenly as possible)
    t    Take the last (i.e. second) half
     ↰   Recurse {and output the result of the recursion}

Vòng thưởng

≤₁|⊇ᵇlᵍḍhtṛ↰

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

Ảnh chụp có nghĩa là ngẫu nhiên, phải không? Đây là phiên bản của chương trình chọn ngẫu nhiên các yếu tố sống sót (trong khi đảm bảo rằng một nửa tồn tại ở mỗi vòng).

≤₁|⊇ᵇlᵍḍhtṛ↰
≤₁            Assert that {the input} is sorted {and output it}
  |           Handler for exceptions (e.g. assertion failures):
   ⊇ᵇ         Find all subsets of the input (preserving order)
     lᵍ       Group them by length
       ḍht    Find the group with median length:
         t      last element of
        h       first
       ḍ        half (split so that the first half is larger)
          ṛ   Pick a random subset from that group
           ↰  Recurse

Điều này sẽ khá ngắn hơn nếu chúng ta có thể sắp xếp lại các yếu tố, nhưng tại sao một thuật toán sắp xếp lại muốn làm điều đó ?

Perl 6 , 30 byte

$!={[<=]($_)??$_!!.[^*/2].&$!}

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

Hàm đệ quy loại bỏ nửa sau của danh sách cho đến khi danh sách được sắp xếp.

Giải trình:

$!={                         }    # Assign the function to $!
    [<=]($_)??                    # If the input is sorted
              $_                  # Return the input
                !!                # Else
                  .[^*/2]         # Take the first half of the list (rounding up)
                         .&$!     # And apply the function again

C # (Trình biên dịch tương tác Visual C #) , 76 byte

g=>{while(!g.OrderBy(x=>x).SequenceEqual(g))g=g.Take(g.Count()/2);return g;}

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

Java 10, 106 97 byte

L->{for(;;L=L.subList(0,L.size()/2)){int p=1<<31,f=1;for(int i:L)f=p>(p=i)?0:f;if(f>0)return L;}}

-9 byte nhờ @ OlivierGrégoire .

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

Chỉ để lại một nửa đầu tiên của danh sách mỗi lần lặp và xóa $\frac{n+1}{2}$ mục nếu kích thước danh sách là số lẻ.

Giải trình:

L->{               // Method with Integer-list as both parameter and return-type
  for(;;           //  Loop indefinitely:
      L=L.subList(0,L.size()/2)){
                   //    After every iteration: only leave halve the numbers in the list
    int p=1<<31,   //   Previous integer, starting at -2147483648
        f=1;       //   Flag-integer, starting at 1
    for(int i:L)   //   Inner loop over the integer in the list:
      f=p>(p=i)?   //    If `a>b` in a pair of integers `a,b`:
         0         //     Set the flag to 0
        :          //    Else (`a<=b`):
         f;        //     Leave the flag the same
    if(f>0)        //   If the flag is still 1 after the loop:
      return L;}}  //    Return the list as result

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

#//.x_/;Sort@x!=x:>x[[;;;;2]]&

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

@Doorknob đã lưu 12 byte

JavaScript (ES6),  49  48 byte

Đã lưu 1 byte nhờ @tsh

Loại bỏ mọi yếu tố thứ 2.

f=a=>a.some(p=c=>p>(p=c))?f(a.filter(_=>a^=1)):a

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

Ruby , 37 byte

->r{r=r[0,r.size/2]while r.sort!=r;r}

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

05AB1E , 8 7 byte

[Ð{Q#ιн

-1 byte nhờ @Emigna .

$\frac{n-1}{2}$ mục nếu kích thước danh sách là số lẻ.

Dùng thử trực tuyến hoặc xác minh thêm một số trường hợp kiểm tra (hoặc xác minh các trường hợp kiểm tra đó từng bước cho mỗi lần lặp ).

7 byte thay thế bởi @Grimy :

ΔÐ{Ê>äн

Xóa cái cuối cùng $\frac{n}{2}$$\frac{n-1}{2}$ mục nếu kích thước danh sách là số lẻ) mỗi lần lặp.

Dùng thử trực tuyến hoặc xác minh thêm một số trường hợp kiểm tra (hoặc xác minh các trường hợp kiểm tra đó từng bước cho mỗi lần lặp ).

Giải trình:

[        # Start an infinite loop:
 Ð       #  Triplicate the list (which is the implicit input-list in the first iteration)
  {Q     #  Sort a copy, and check if they are equal
    #    #   If it is: Stop the infinite loop (and output the result implicitly)
  ι      #  Uninterweave: halve the list into two parts; first containing all even-indexed
         #  items, second containing all odd-indexed items (0-indexed)
         #   i.e. [4,5,2,8,1] → [[4,2,1],[5,8]]
   н     #  And only leave the first part

Δ        # Loop until the result no longer changes:
 Ð       #  Triplicate the list (which is the implicit input-list in the first iteration)
  {Ê     #  Sort a copy, and check if they are NOT equal (1 if truthy; 0 if falsey)
    >    #  Increase this by 1 (so 1 if the list is sorted; 2 if it isn't sorted)
     ä   #  Split the list in that many parts
      н  #  And only leave the first part
         # (and output the result implicitly after it no longer changes)

TI-BASIC (TI-84), 47 42 45 44 byte

-1 byte nhờ @SolomonUcko!

Ans→L1:Ans→L2:SortA(L1:While max(L1≠Ans:iPart(.5dim(Ans→dim(L2:L2→L1:SortA(L1:End:Ans

Danh sách đầu vào là trong Ans.
Đầu ra là trong Ansvà được in ra.

Giải trình:

Ans→L1                  ;store the input into two lists
Ans→L2
SortA(L1                ;sort the first list
                        ; two lists are needed because "SortA(" edits the list it sorts
While max(L1≠Ans        ;loop until both lists are strictly equal
iPart(.5dim(Ans→dim(L2  ;remove the latter half of the second list
                        ; removes (n+1)/2 elements if list has an odd length
L2→L1                   ;store the new list into the first list (updates "Ans")
SortA(L1                ;sort the first list
End
Ans                     ;implicitly output the list when the loop ends

Lưu ý: TI-BASIC là ngôn ngữ được mã hóa. Số lượng ký tự không bằng số byte.

Thạch , 7 byte

m2$⁻Ṣ$¿

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

Haskell , 57 55 byte (chỉ nhờ ASCII)

f x|or$zipWith(>)x$tail x=f$take(div(length x)2)x|1>0=x

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

Mã gốc:

f x|or$zipWith(>)x(tail x)=f(take(div(length x)2)x)|1>0=x

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

Ung dung:

f xs | sorted xs = f (halve xs)
     | otherwise = xs

sorted xs = or (zipWith (>) xs (tail xs))

halve xs = take (length xs `div` 2) xs

Octave , 49 byte

l=input('');while(~issorted(l))l=l(1:2:end);end;l

Hãy thử trực tuyến!Đây là một hành trình mà nhàm chán hơn là tốt hơn. Lưu ý hai mục thú vị hơn nhiều dưới đây:

50 byte

function l=q(l)if(~issorted(l))l=q(l(1:2:end));end

Hãy thử trực tuyến!Thay vì giải pháp mệnh lệnh không thú vị, chúng ta có thể thực hiện một giải pháp đệ quy, chỉ với một byte bổ sung.

53 byte

f(f=@(g)@(l){l,@()g(g)(l(1:2:end))}{2-issorted(l)}())

Hãy thử trực tuyến! Vâng. Một hàm ẩn danh đệ quy, nhờ câu trả lời xuất sắc của @ Barecat về câu hỏi mẹo của tôi . Hàm ẩn danh trả về hàm ẩn danh đệ quy bằng cách định nghĩa chính nó trong danh sách đối số của nó. Tôi thích chức năng ẩn danh. Mmmmm.

MATL , 11 byte

tv`1L)ttS-a

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

Điều này hoạt động bằng cách loại bỏ mọi mục thứ hai.

Giải trình

t      % Take a row vector as input (implicit). Duplicate
v      % Vertically concatenate the two copies of the row vector. When read with
       % linear indexing (down, then across), this effectively repeats each entry
`      % Do...while
  1L)  %   Keep only odd-indexed entries (1-based, linear indexing)
  t    %   Duplicate. This will leave a copy for the next iteration
  tS   %   Duplicate, sort
  -a   %   True if the two arrays differ in any entry
       % End (implicit). A new iteration starts if the top of the stack is true
       % Display (implicit). Prints the array that is left on the stack

Japt , 10 byte

eUñ)?U:ßUë

Thử nó

eUñ)?U:ßUë     :Implicit input of array U
e              :Compare equality with
 Uñ            :  U sorted
   )           :End compare
    ?U:        :If true then return U else
       ß       :Run the programme again with input
        Uë     :  Every second element of U

Java (JDK) , 102 byte

n->{for(;n.stream().reduce((1<<31)+0d,(a,b)->a==.5|b<a?.5:b)==.5;n=n.subList(0,n.size()/2));return n;}

Đã có câu trả lời C #, vì vậy tôi quyết định thử dùng câu trả lời Java.

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

Pha lê , 58 byte

Với Array#sort( 58 byte ):

->(a : Array(Int32)){while a!=a.sort;a.pop a.size/2;end;a}

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

Không có Array#sort( 101 byte ):

->(a : Array(Int32)){while a.map_with_index{|e,i|e>a.fetch i+1,Int32::MAX}.any?;a.pop a.size/2;end;a}

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

Chồng , 6 5 byte

Lưu 1 byte nhờ Zgarb

ΩΛ<Ċ2

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

Giải trình

ΩΛ<Ċ2
Ω         Repeat until
 Λ<         all adjacent pairs are sorted (which means the list is sorted)
   Ċ2         drop every second element from the list

Gaia , 9 8 byte

eo₌⟨2%⟩↻

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

Giải trình:

e		| eval input as a list
       ↻	| until
 o		| the list is sorted
  ₌		| push additional copy
   ⟨2%⟩  	| and take every 2nd element

Julia 1.0 , 30 byte

-x=x>sort(x) ? -x[1:2:end] : x

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

Mất mọi phần tử thứ hai của mảng nếu không được sắp xếp.

C ++ (gcc) , 103 byte

Tôi không thể nhận xét, nhưng tôi đã cải thiện phiên bản từ Movatica bằng cách giảm bao gồm và sử dụng tự động.

-2 byte: trần mèo
-2 byte: chỉ ASCII

#include<regex>
auto f(auto l){while(!std::is_sorted(l.begin(),l.end()))l.resize(l.size()/2);return l;}

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

VDM-SL , 99 byte

f(i)==if forall x in set inds i&x=1or i(x-1)<=i(x) then i else f([i(y)|y in set inds i&y mod 2=0]) 

Không bao giờ gửi trong vdm trước, vì vậy không chắc chắn về các quy tắc ngôn ngữ cụ thể. Vì vậy, tôi đã gửi như một định nghĩa chức năng trong đó có mộtseq of int và trả vềseq of int

Một chương trình đầy đủ để chạy có thể trông như thế này:

functions
f:seq of int +>seq of int
f(i)==if forall x in set inds i&x=1or i(x-1)<=i(x) then i else f([i(y)|y in set inds i&y mod 2=0]) 

Bình thường, 10 byte

.W!SIHhc2Z

Hãy thử trực tuyến tại đây . Điều này loại bỏ nửa thứ hai trên mỗi lần lặp, làm tròn xuống. Để thay đổi nó để loại bỏ nửa đầu, làm tròn lên, thay đổi hthành e.

.W!SIHhc2ZQ   Q=eval(input())
              Trailing Q inferred
  !SIH        Condition function - input variable is H
   SIH          Is H invariant under sorting?
  !             Logical not
      hc2Z    Iteration function - input variable is Z
       c2Z      Split Z into 2 halves, breaking ties to the left
      h         Take the first half
.W        Q   With initial value Q, execute iteration function while condition function is true

C ++ (gcc) , 139 137 116 byte

-2 byte sox đến trần, -21 byte sox với PeterZuger

#include<regex>
auto f(std::vector<int>l){while(!std::is_sorted(l.begin(),l.end()))l.resize(-~l.size()/2);return l;}

Thay đổi kích thước vectơ thành nửa đầu của nó cho đến khi nó được sắp xếp.

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

K (oK) , 22 20 byte

Giải pháp:

{(*2 0N#x;x)x~x@<x}/

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

Lặp lại đầu vào cho đến khi nó được sắp xếp ... nếu nó không được sắp xếp, hãy lấy n / 2 mục đầu tiên.

{(*2 0N#x;x)x~x@<x}/ / the solution
{                 }/ / lambda that iterates
                <x   / indices that sort x ascending (<)
              x@     / apply (@) these indices back to x
            x~       / matches (~) x? returns 0 or 1
 (       ; )         / 2-item list which we index into
          x          / original input (ie if list was sorted)
       #x            / reshape (#) x
   2 0N              / as 2 rows
  *                  / take the first one      

Chỉnh sửa:

• -2 byte nhờ ngn

Julia 1.0 , 33 byte

-a=issorted(a) ? a : -a[1:end÷2]

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

Võng mạc , 38 byte

\d+
*
/(_+),(?!\1)/+`,_+(,?)
$1
_+
$.&

Hãy thử trực tuyến! Có các số được phân tách bằng dấu phẩy. Giải trình:

\d+
*

Chuyển đổi sang unary.

/(_+),(?!\1)/+`

Lặp lại trong khi danh sách chưa được sắp xếp ...

,_+(,?)
$1

... Xóa mọi phần tử chẵn.

_+
$.&

Chuyển đổi thành số thập phân.

C (gcc) , 66 byte

Tách ra nửa sau của danh sách mỗi lần lặp ( n/2+1các phần tử nếu độ dài là số lẻ).

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

Đưa đầu vào như một con trỏ đến điểm bắt đầu của một mảng inttheo sau bởi chiều dài của nó. Đầu ra bằng cách trả về độ dài mới của mảng (sắp xếp tại chỗ).

t(a,n,i)int*a;{l:for(i=0;i<n-1;)if(a[i]>a[++i]){n/=2;goto l;}a=n;}

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

t(a, n, i) int *a; { // take input as a pointer to an array of int, followed by its length; declare a loop variable i
  l: // jump label, will be goto'ed after each snap
  for(i = 0; i < n - 1; ) { // go through the whole array …
    if(a[i] > a[++i]) { // … if two elements are in the wrong order …
      n /= 2; // … snap off the second half …
      goto l; // … and start over
    }
  }
  a = n; // implicitly return the new length
}