อัลกอริทึมการเรียงลำดับมีลักษณะดังนี้:

ในขณะที่ไม่มีการเรียงลำดับรายการให้จัดครึ่งหนึ่งของรายการทั้งหมด (นำออกจากรายการ) ทำต่อไปจนกว่าจะมีการเรียงลำดับรายการหรือมีเพียงหนึ่งรายการที่เหลืออยู่ (ซึ่งเรียงลำดับตามค่าเริ่มต้น) อัลกอริทึมการเรียงลำดับนี้อาจให้ผลลัพธ์ที่แตกต่างกันขึ้นอยู่กับการใช้งาน

ขั้นตอนการลบไอเท็มนั้นขึ้นอยู่กับการนำไปใช้ในการตัดสินใจ แต่รายการนั้นควรมีความยาวครึ่งหนึ่งก่อนที่จะผ่านขั้นตอนการลบไอเท็มครั้งเดียว อัลกอริทึมของคุณอาจตัดสินใจที่จะลบครึ่งแรกหรือรายการครึ่งสุดท้ายของรายการรายการคี่ทั้งหมดแม้กระทั่งรายการทีละรายการจนกว่ารายการจะมีความยาวครึ่งหนึ่งหรือไม่ได้กล่าวถึง

รายการอินพุตสามารถมีจำนวนไอเท็มตามอำเภอใจ (ภายในเหตุผลสมมติว่ามีมากถึง 1,000 ไอเท็ม) ไม่เพียง แต่รายการที่แบ่งแยกได้อย่างสมบูรณ์แบบของรายการ 2 ^ n คุณจะต้องลบรายการ (n + 1) / 2 หรือ (n-1) / 2 หากรายการนั้นเป็นเลขคี่ฮาร์ดโค้ดหรือตัดสินใจสุ่มระหว่างรันไทม์ ตัดสินใจด้วยตัวคุณเอง: ธานอสจะทำอะไรถ้าจักรวาลมีสิ่งมีชีวิตแปลก ๆ จำนวนหนึ่ง?

รายการจะถูกจัดเรียงหากไม่มีรายการใดเล็กกว่ารายการก่อนหน้า รายการที่ซ้ำกันอาจเกิดขึ้นในอินพุตและอาจเกิดขึ้นในเอาต์พุต

โปรแกรมของคุณควรใช้อาร์เรย์ของจำนวนเต็ม (ผ่าน stdin หรือพารามิเตอร์ทั้งรายการหรือพารามิเตอร์อาร์เรย์) และส่งกลับอาร์เรย์ที่เรียงลำดับแล้ว (หรือพิมพ์ไปยัง stdout)

ตัวอย่าง:

// 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] สามารถให้ผลลัพธ์ที่แตกต่าง:

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

หรือ:

// 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

หรือ:

// 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

หรือ:

// 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 ไบต์

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

ลองออนไลน์!

Python 3 , 38 42 39 ไบต์

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

ลองออนไลน์!

-3 bytes ขอบคุณ @JoKing และ @Quuxplusone

Python 2 , 39 ไบต์

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

ลองออนไลน์!

Brachylog (v2), 6 ไบต์

≤₁|ḍt↰

ลองออนไลน์!

นี่คือการส่งฟังก์ชั่น อินพุตจากด้านซ้ายส่งออกไปทางขวาตามปกติ (ลิงก์ TIO ใช้อาร์กิวเมนต์บรรทัดคำสั่งที่ล้อมฟังก์ชันเข้ากับโปรแกรมเต็มโดยอัตโนมัติเพื่อให้คุณเห็นการทำงาน)

คำอธิบาย

≤₁|ḍ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}

รอบโบนัส

≤₁|⊇ᵇlᵍḍhtṛ↰

ลองออนไลน์!

สแน็ปอินหมายถึงการสุ่มใช่ไหม ต่อไปนี้เป็นเวอร์ชันของโปรแกรมที่เลือกองค์ประกอบที่ยังมีชีวิตอยู่แบบสุ่ม (ในขณะที่ทำให้แน่ใจว่าครึ่งหนึ่งจะอยู่รอดในแต่ละรอบ)

≤₁|⊇ᵇ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

นี่จะค่อนข้างสั้นกว่านี้หากเราสามารถจัดลำดับองค์ประกอบใหม่ได้ แต่ทำไมอัลกอริธึมการเรียงลำดับต้องการทำเช่นนั้น ?

Perl 6 , 30 ไบต์

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

ลองออนไลน์!

ฟังก์ชันเรียกซ้ำที่ลบครึ่งหลังของรายการออกจนกว่ารายการจะถูกเรียงลำดับ

คำอธิบาย:

$!={                         }    # 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 # (Visual C # Interactive Compiler) , 76 ไบต์

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

ลองออนไลน์!

Java 10, 106 97 ไบต์

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 ไบต์ขอบคุณที่@ OlivierGrégoire

ลองออนไลน์

$\frac{n+1}{2}$

คำอธิบาย:

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

ภาษา Wolfram (Mathematica)ขนาด 30 ไบต์

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

ลองออนไลน์!

@Doorknob บันทึกแล้ว 12 ไบต์

JavaScript (ES6),  49  48 ไบต์

บันทึกแล้ว 1 ไบต์ขอบคุณ @tsh

ลบทุกองค์ประกอบที่ 2

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

ลองออนไลน์!

Ruby , 37 ไบต์

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

ลองออนไลน์!

05AB1E , 8 7 ไบต์

[Ð{Q#ιн

-1 ไบต์ขอบคุณที่@Emigna

$\frac{n-1}{2}$

ลองใช้แบบออนไลน์หรือตรวจสอบกรณีทดสอบเพิ่มเติมอีกหลายกรณี (หรือตรวจสอบกรณีทดสอบเหล่านั้นด้วยการทำซ้ำแต่ละขั้นตอน )

7 ไบต์ทางเลือกโดย@Grimy :

ΔÐ{Ê>äн

ลบล่าสุด$\frac{n}{2}$$\frac{n-1}{2}$

ลองใช้แบบออนไลน์หรือตรวจสอบกรณีทดสอบเพิ่มเติมอีกหลายกรณี (หรือตรวจสอบกรณีทดสอบเหล่านั้นด้วยการทำซ้ำแต่ละขั้นตอน )

คำอธิบาย:

[        # 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 ไบต์

-1 ไบต์ขอบคุณ @SolomonUcko!

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

Ansรายการอยู่ในการป้อนข้อมูล
เอาต์พุตอยู่ในAnsและพิมพ์ออกมาโดยปริยาย

คำอธิบาย:

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

หมายเหตุ: TI-BASIC เป็นภาษาโทเค็น จำนวนตัวอักษรไม่เท่ากับจำนวนไบต์

เยลลี่ขนาด 7 ไบต์

m2$⁻Ṣ$¿

ลองออนไลน์!

Haskell , 57 55 ไบต์ (ขอบคุณ ASCII-only)

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

ลองออนไลน์!

รหัสเดิม:

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

ลองออนไลน์!

Ungolfed:

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

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

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

อ็อกเทฟ 49 ไบต์

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

ลองออนไลน์! นี่คือการเดินทางที่น่าเบื่อมากขึ้นดีกว่า สังเกตรายการที่น่าสนใจอีกสองรายการด้านล่าง:

50 ไบต์

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

ลองออนไลน์! แทนที่จะเป็นวิธีแก้ปัญหาที่ไม่น่าสนใจเราสามารถแก้ปัญหาแบบวนซ้ำได้เพียงหนึ่งไบต์เท่านั้น

53 ไบต์

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

ลองออนไลน์! อ๋อ ฟังก์ชั่นไม่ระบุชื่อแบบเรียกซ้ำขอบคุณคำตอบที่ยอดเยี่ยมของ @ เพดานแมวสำหรับคำถามเคล็ดลับของฉัน ฟังก์ชันที่ไม่ระบุชื่อที่ส่งคืนฟังก์ชันที่ไม่ระบุชื่อแบบเรียกซ้ำโดยกำหนดตัวเองในรายการอาร์กิวเมนต์ ฉันชอบฟังก์ชั่นที่ไม่ระบุชื่อ mmmmm

MATL 11 ไบต์

tv`1L)ttS-a

ลองออนไลน์!

วิธีนี้ใช้ได้โดยลบทุกรายการที่สอง

คำอธิบาย

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 ไบต์

eUñ)?U:ßUë

ลองมัน

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 ไบต์

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 # อยู่แล้วดังนั้นฉันตัดสินใจลองใช้คำตอบ Java

ลองออนไลน์!

คริสตัล 58 ไบต์

ด้วยArray#sort( 58 ไบต์ ):

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

ลองออนไลน์!

ไม่มีArray#sort( 101 ไบต์ ):

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

ลองออนไลน์!

Husk , 6 5 ไบต์

บันทึก 1 ไบต์ขอบคุณ Zgarb

ΩΛ<Ċ2

ลองออนไลน์!

คำอธิบาย

ΩΛ<Ċ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 ไบต์

eo₌⟨2%⟩↻

ลองออนไลน์!

คำอธิบาย:

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 ไบต์

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

ลองออนไลน์!

ใช้ทุกองค์ประกอบที่สองของอาร์เรย์หากไม่ได้เรียงลำดับ

C ++ (gcc) , 103 ไบต์

ฉันไม่สามารถแสดงความคิดเห็น แต่ฉันปรับปรุงเวอร์ชันจาก movatica โดยลดการรวมและการใช้อัตโนมัติ

-2 Bytes: ceilingcat
-2 Bytes: ASCII-only

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

ลองออนไลน์!

VDM-SL , 99 ไบต์

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]) 

ไม่เคยส่งใน vdm มาก่อนจึงไม่แน่ใจในกฎเฉพาะภาษา ดังนั้นฉันจึงส่งคำจำกัดความของฟังก์ชั่นซึ่งใช้ a seq of intและส่งคืน aseq of int

โปรแกรมเต็มรูปแบบที่จะทำงานอาจมีลักษณะเช่นนี้:

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]) 

Pyth, 10 ไบต์

.W!SIHhc2Z

ลองออนไลน์ได้ที่นี่ สิ่งนี้จะลบครึ่งหลังของการวนซ้ำแต่ละครั้งปัดเศษลง จะเปลี่ยนเป็นลบในช่วงครึ่งแรกปัดเศษขึ้นให้เปลี่ยนไปhe

.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 ไบต์

-2 ไบต์ thanx ถึง ceilingcat, -21 ไบต์ thanx ถึง PeterZuger

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

ปรับขนาดเวกเตอร์เป็นครึ่งแรกจนกว่าจะถูกจัดเรียง

ลองออนไลน์!

K (oK) , 22 20 ไบต์

วิธีการแก้:

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

ลองออนไลน์!

ทำซ้ำการป้อนข้อมูลจนกว่าจะเรียงลำดับ ... หากไม่ได้เรียงลำดับให้ใช้รายการ n / 2 ก่อน

{(*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      

การแก้ไข:

• -2ไบต์ขอบคุณ ngn

Julia 1.0 , 33 bytes

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

ลองออนไลน์!

เรติน่า , 38 ไบต์

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

ลองออนไลน์! ใช้ตัวเลขคั่นด้วยเครื่องหมายจุลภาค คำอธิบาย:

\d+
*

แปลงเป็นเอก

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

ทำซ้ำขณะที่ไม่มีการเรียงลำดับรายการ ...

,_+(,?)
$1

... ลบทุกองค์ประกอบคู่

_+
$.&

แปลงเป็นทศนิยม

C (gcc) , 66 ไบต์

Snaps off ครึ่งหลังของรายการแต่ละการวนซ้ำ ( n/2+1องค์ประกอบถ้าความยาวเป็นเลขคี่)

ลองออนไลน์!

รับอินพุตเป็นตัวชี้ไปยังจุดเริ่มต้นของอาร์เรย์intตามด้วยความยาว เอาต์พุตโดยส่งคืนความยาวใหม่ของอาร์เรย์ (เรียงลำดับแบบแทนที่)

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

เวอร์ชันที่ไม่ถูกปรับแต่ง:

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
}