Merge sortเป็นอัลกอริทึมการเรียงลำดับที่ทำงานโดยแยกรายการที่กำหนดเป็นครึ่งแล้วทำการเรียงลำดับซ้ำทั้งรายการเล็ก ๆ และรวมกลับเข้าด้วยกันเป็นหนึ่งรายการเรียงลำดับ เคสพื้นฐานของการเรียกซ้ำจะมาถึงรายการเดี่ยวซึ่งไม่สามารถแยกได้อีกต่อไป แต่เรียงตามนิยามแล้ว

การดำเนินการของอัลกอริทึมในรายการ[1,7,6,3,3,2,5]สามารถมองเห็นได้ด้วยวิธีดังต่อไปนี้:

       [1,7,6,3,3,2,5]
       /             \      split
   [1,7,6,3]       [3,2,5]
    /     \        /    \   split
 [1,7]   [6,3]   [3,2]  [5]
 /   \   /   \   /   \   |  split
[1] [7] [6] [3] [3] [2] [5]
 \   /   \   /   \   /   |  merge
 [1,7]   [3,6]   [2,3]  [5]
    \     /         \   /   merge
   [1,3,6,7]       [2,3,5]
       \             /      merge
       [1,2,3,3,5,6,7]

งาน

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

[1,7,6,3,3,2,5]
[1,7,6,3][3,2,5]
[1,7][6,3][3,2][5]
[1][7][6][3][3][2][5]
[1,7][3,6][2,3][5]
[1,3,6,7][2,3,5]
[1,2,3,3,5,6,7]

นอกจากนี้สัญกรณ์รายการที่สมเหตุสมผลก็ดีดังนั้นต่อไปนี้จะเป็นผลลัพธ์ที่ถูกต้อง:

1 7 6 3 3 2 5
1 7 6 3|3 2 5
1 7|6 3|3 2|5
1|7|6|3|3|2|5
1 7|3 6|2 3|5
1 3 6 7|2 3 5
1 2 3 3 5 6 7

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

นี่คือcode-golfดังนั้นโค้ดที่สั้นที่สุดในภาษาใด ๆ ที่วัดเป็นไบต์จะเป็นผู้ชนะ

กรณีทดสอบ

ตามที่ระบุไว้ข้างต้นรูปแบบที่แท้จริงและวิธีแบ่งรายการในครึ่งนั้นขึ้นอยู่กับคุณ

[10,2]
[10][2]
[2,10]

[4,17,1,32]
[4,17][1,32]
[4][17][1][32]
[4,17][1,32]
[1,4,17,32]

[6,5,4,3,2,1]
[6,5,4][3,2,1]
[6,5][4][3,2][1]
[6][5][4][3][2][1]
[5,6][4][2,3][1] <- Important: This step cannot be [5,6][3,4][1,2], because 3 and 4 are on different branches in the the tree
[4,5,6][1,2,3]
[1,2,3,4,5,6]

Haskell , 137 128 127 125 121 109 106 ไบต์

^{(-2) + (- 4) = (- 6) ไบต์ขอบคุณnimi ! การเปลี่ยนเพื่อรวบรวมขั้นตอนทั้งหมดในรายการ (อีกครั้งเนื่องจาก nimi) ช่วยให้ประหยัดได้อีก 12 ไบต์}

^{อีก 3 ไบต์เนื่องจากLaikoniมีรูปแบบการเชื่อมโยงยามและการใช้รายการความเข้าใจที่ชาญฉลาดในการเข้ารหัสการ์ด}

import Data.List
g x|y<-x>>=h=x:[z|x/=y,z<-g y++[sort<$>x]]
h[a]=[[a]]
h x=foldr(\x[b,a]->[x:a,b])[[],[]]x

ลองออนไลน์!

การแยกรายการออกเป็นองค์ประกอบคี่และองค์ประกอบที่อยู่ในตำแหน่งนั้นคือรหัสที่สั้นกว่าในส่วนที่เป็นลำดับสองส่วนเนื่องจากเราไม่จำเป็นต้องวัดค่าในตอนlengthนั้น

ทำงานโดย "การพิมพ์" รายการจากนั้นเรียกใช้รายการแบบแยก ( x >>= h) อีกครั้งหากมีการแยกรายการเสร็จแล้วและ "การพิมพ์" รายการที่เรียงลำดับ เริ่มต้นด้วยรายการอินพุตเดียว สมมติว่าอินพุตไม่ว่าง และแทนที่จะพิมพ์จริงเพียงเก็บรวบรวมไว้ในรายการ

รายการที่ผลิตโดย g[[6,5..1]]พิมพ์บรรทัดต่อบรรทัดคือ:

[[6,5,4,3,2,1]]
[[6,4,2],[5,3,1]]
[[6,2],[4],[5,1],[3]]
[[6],[2],[4],[5],[1],[3]]
[[2,6],[4],[1,5],[3]]
[[2,4,6],[1,3,5]]
[[1,2,3,4,5,6]]

ภาษา Wolfram (Mathematica) , 146 127 111 102 ไบต์

Join[u=Most[#/.a:{_,b=__Integer}:>TakeDrop[a,;;;;2]&~FixedPointList~#],Reverse@Most@u/.a:{b}:>Sort@a]&

ลองออนไลน์!

ส่งคืน a Listที่มีขั้นตอน

คำอธิบาย

#/.a:{_,b=__Integer}:>TakeDrop[a,;;;;2]&

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

u=Most[... &~FixedPointList~#]

ทำซ้ำจนกระทั่งไม่มีอะไรเปลี่ยนแปลง (เช่นรายการย่อยทั้งหมดมีความยาว -1) เก็บผลลัพธ์ระดับกลางทั้งหมด ร้านค้านี้ ( Listทุกขั้นตอน) uใน

Reverse@Most@u

วางองค์ประกอบสุดท้ายของuและย้อนกลับ

... /.a:{b}:>Sort@a

จากผลลัพธ์ด้านบนให้เรียงลำดับรายการทั้งหมดของรายการจำนวนเต็ม

ทำความสะอาด , 228 206 168 157 140 121 104 ไบต์

สร้างรายการขั้นตอนจากปลายเข้าด้านในโดยใช้ข้อเท็จจริงที่ว่า nองค์ประกอบ -th จากจุดสิ้นสุดเป็นรุ่นที่เรียงลำดับของnองค์ประกอบ -th จากจุดเริ่มต้น

ไอเดียจากคอมเม้นของ JungHwan Min

import StdEnv
@u#(a,b)=splitAt(length u/2)u
=if(a>[])[[u]:[x++y\\y<- @b&x<- @a++ @a++ @a]][]++[[sort u]]

ลองออนไลน์!

ถ่าน , 145 133 123 122 ไบต์

≔⟦⪪Ｓ ⟧θＷ⊖Ｌ§θ⁰«⟦⪫Ｅθ⪫κ ¦|⟧≔ＥＥ⊗Ｌθ§θ÷λ²✂κ﹪λ²Ｌκ²θ»⟦⪫ΦＥθ⪫ι ι|⟧Ｗ⊖Ｌθ«≔⮌θη≔⟦⟧θＷη«≔⊟ηε≔⟦⟧ζＦ⊟η«≔εδ≔⟦⟧εＦδ⊞⎇‹ＩμＩλζεμ⊞ζλ»⊞θ⁺ζε»⟦⪫Ｅθ⪫κ ¦|

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด ยังคงต้องแก้ไขข้อบกพร่อง Charcoal ...แก้ไข: บันทึก 5 ไบต์โดยใช้ double Mapเป็นความเข้าใจของชายยากจน บันทึก 4 ไบต์โดยใช้Popเพื่อทำซ้ำสองครั้งในอาร์เรย์ ที่บันทึกไว้ 3 Pushไบต์โดยใช้การเรียงต่อกันแทน บันทึก 10 ไบต์โดยมาพร้อมกับwhileสภาพนักกอล์ฟที่หลีกเลี่ยงบั๊กถ่าน บันทึก 1 ไบต์ด้วยการค้นพบว่า Charcoal มีผู้ดำเนินการตัวกรองอย่างแน่นอน คำอธิบาย:

≔⟦⪪Ｓ ⟧θ

qแยกการป้อนข้อมูลในช่องว่างแล้วห่อผลในอาร์เรย์นอกประหยัดที่

Ｗ⊖Ｌ§θ⁰«

ทำซ้ำในขณะที่องค์ประกอบแรกของqมีมากกว่าหนึ่งองค์ประกอบ (องค์ประกอบแรกของqมักจะมีองค์ประกอบมากที่สุดเพราะวิธีที่รายการจะแบ่งออกเป็นสอง)

⟦⪫Ｅθ⪫κ ¦|⟧

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

≔ＥＥ⊗Ｌθ§θ÷λ²✂κ﹪λ²Ｌκ²θ»

สร้างรายการโดยการทำซ้ำองค์ประกอบของแต่ละqแล้ว map กว่ารายการและใช้เวลาครึ่งหนึ่งของแต่ละรายการ (โดยใช้วิธีการที่องค์ประกอบอื่น ๆ ) qประหยัดหลังผลใน

⟦⪫ΦＥθ⪫ι ι|⟧

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

Ｗ⊖Ｌθ«

ทำซ้ำขณะที่qมีองค์ประกอบมากกว่าหนึ่งองค์ประกอบ (รหัสต่อไปนี้ต้องการองค์ประกอบจำนวนคู่)

≔⮌θη≔⟦⟧θ

คัดลอกqไปยังhแต่กลับด้าน (ดูด้านล่าง) และรีเซ็ตqเป็นรายการว่าง

Ｗη«

ทำซ้ำจนกว่าhจะว่างเปล่า

≔⊟ηε

สารสกัดจากองค์ประกอบต่อไปของการเข้าสู่h e( Popสารสกัดจากท้ายซึ่งเป็นเหตุผลที่ฉันต้องย้อนกลับq)

≔⟦⟧ζ

กำหนดค่าเริ่มต้นzเป็นรายการว่าง

Ｆ⊟η«

hห่วงมากกว่าองค์ประกอบขององค์ประกอบถัดไปของ

≔εδ≔⟦⟧ε

คัดลอกeไปdและการตั้งค่าeไปยังรายการที่ว่างเปล่า

Ｆδ

dห่วงมากกว่าองค์ประกอบของ

⊞⎇‹ＩμＩλζεμ

ผลักดันให้zหรือขึ้นอยู่กับว่าพวกเขาจะมีขนาดเล็กกว่าองค์ประกอบปัจจุบันขององค์ประกอบต่อไปของeh

⊞ζλ»

ผลักดันองค์ประกอบปัจจุบันขององค์ประกอบต่อไปของhการzการ

⊞θ⁺ζε»

Concatenate zมีองค์ประกอบใด ๆ ที่เหลืออยู่ในและผลักดันว่าe qนี่เป็นการผสานที่สมบูรณ์ของสององค์ประกอบของhเสร็จสมบูรณ์ผสานสององค์ประกอบของ

⟦⪫Ｅθ⪫κ ¦|

พิมพ์องค์ประกอบของการqรวมเข้ากับช่องว่างและเส้นแนวตั้ง

งูหลาม 2 , 145 144 ไบต์

^{แนวคิดจากความคิดเห็นของ JungHwan Min
-1 ไบต์ขอบคุณ Jonathan Frech}

p=input()
l=[[p]]
i=0
while 2**i<len(p):l[i+1:i+1]=[sum([[x[1::2],x[::2]][len(x)<2:]for x in l[i]],[]),map(sorted,l[i])];i+=1
for s in l:print s

ลองออนไลน์!

JavaScript (ES6), 145 ไบต์

f=a=>a.join`|`+(a[0][1]?`
${f([].concat(...a.map(b=>b[1]?[b.slice(0,c=-b.length/2),b.slice(c)]:[b])))}
`+a.map(b=>b.sort((x,y)=>x-y)).join`|`:``)

f([[6,5,4,3,2,1]])จะเข้าเป็นอาร์เรย์ภายในอาร์เรย์คือ ทำงานโดยการสร้างบรรทัดแรกและบรรทัดสุดท้ายของเอาต์พุตจากนั้นแยกและเรียกตัวเองอีกครั้งจนกระทั่งอาร์เรย์ย่อยทุกอันมีความยาว 1 นี่คือการสาธิตขั้นพื้นฐานเกี่ยวกับวิธีการทำงาน:

f([[6,5,4,3,2,1]]):
  6,5,4,3,2,1
  f([[6,5,4],[3,2,1]]):
    6,5,4|3,2,1
    f([[6,5],[4],[3,2],[1]]):
      6,5|4|3,2|1
      f([[6],[5],[4],[3],[2],[1]]):
        6|5|4|3|2|1
      end f
      5,6|4|2,3|1
    end f
    4,5,6|1,2,3
  end f
  1,2,3,4,5,6
end f

Husk , 14 ไบต์

S+ȯ†O↔hUmfL¡ṁ½

รับอาร์เรย์ที่มีอาร์เรย์เดียว ลองออนไลน์!

คำอธิบาย

S+ȯ†O↔hUmfL¡ṁ½  Implicit input, say A = [[4,17,32,1]].
           ¡    Iterate this function on A:
            ṁ½   Split each array in two, concatenate results: [[4,17],[32,1]]
                Result is [[[4,17,32,1]],
                           [[4,17],[32,1]],
                           [[4],[17],[32],[1]],
                           [[4],[],[17],[],[32],[],[1],[]],
                           ...
        mfL     Map filter by length, removing empty arrays.
                Result is [[[4,17,32,1]],
                           [[4,17],[32,1]],
                           [[4],[17],[32],[1]],
                           [[4],[17],[32],[1]],
                           ...
       U        Longest prefix of unique elements:
                       P = [[[4,17,32,1]],[[4,17],[32,1]],[[4],[17],[32],[1]]]
      h         Remove last element: [[[4,17,32,1]],[[4,17],[32,1]]]
     ↔          Reverse: [[[4,17],[32,1]],[[4,17,32,1]]]
   †O           Sort each inner array: [[[4,17],[1,32]],[[1,4,17,32]]]
S+ȯ             Concatenate to P:
                           [[[4,17,32,1]],
                            [[4,17],[32,1]],
                            [[4],[17],[32],[1]],
                            [[4,17],[1,32]],
                            [[1,4,17,32]]]
                Implicitly print.

บิวท์อิน½จะใช้อาเรย์แล้วแยกออกมาตรงกลาง หากความยาวของมันเป็นคี่ส่วนแรกจะยาวโดยองค์ประกอบหนึ่ง ซิงเกิลอาร์เรย์[a]ผลลัพธ์ใน[[a],[]]และอาร์เรย์ที่ว่างเปล่า[]ให้ดังนั้นจึงเป็นเรื่องจำเป็นที่จะเอาอาร์เรย์ที่ว่างเปล่าก่อนที่จะใช้[[],[]]U

Stax , 116 (÷ 3>) 38 29 ไบต์^CP437

-9 ไบต์ต่อความคิดเห็นโดย @recursive ตอนนี้การป้อนข้อมูลจะได้รับเป็นซิงเกิลตันที่มีองค์ประกอบเพียงอย่างเดียวคืออาร์เรย์ของตัวเลขที่จะเรียงลำดับ

ƒ3s}óºE/ßB╢↕êb∩áαπüµrL╞¶è,te+

ลองออนไลน์!

เวอร์ชันที่คลายการบีบอัดที่มี 35 ไบต์:

{c{Jm'|*Pc{2Mm:f{fc{Dm$wW{{eoJm'|*P

คำอธิบาย

รหัสสามารถแยกเป็นสองส่วน ส่วนแรกแบ่งภาพเป็นภาพและส่วนที่สองแสดงภาพรวม

รหัสสำหรับการแยกการแสดงภาพ:

{                      w    Do the following while the block generates a true value
 c                          Copy current nested array for printing
  {Jm                       Use spaces to join elements in each part
     '|*                    And join different parts with vertical bar 
        P                   Pop and print

         c                  Copy current nested array for splitting
          {2Mm              Separate each element of the array to two smaller parts with almost the same size
                                That is, if the number of elements is even, partition it evenly.
                                Otherwise, the first part will have one more element than the second.
              :f            Flatten the array once
                {f          Remove elements that are empty arrays

                  c         Copy the result for checking 
                   {Dm$     Is the array solely composed of singletons?
                            If yes, ends the loop.

รหัสสำหรับการแสดงภาพรวม:

W              Execute the rest of the program until the stack is empty
 {{eoJm        For each part, sort by numeric value, then join with space
       '|*     Join the parts with vertical bar
          P    Pop and print the result

เวอร์ชันเก่าสร้างโครงสร้างรายการแบบซ้อน

{{cc0+=!{x!}Mm',*:}}Xd;%v:2^^{;s~{c^;<~sc%v,*{2M{s^y!svsm}M}YZ!x!Q,dmU@e;%v:2^{;%v:2^-N~0{c;={scc0+=Cc%v!C:f{o}{scc0+=C{s^y!svsm}?}Y!cx!P,dcm

cc0+= ถูกใช้สามครั้งในรหัสเพื่อตรวจสอบว่าส่วนบนสุดของสแต็กเป็นสเกลาร์หรืออาร์เรย์

{{cc0+=!{x!}Mm',*:}}Xสร้างบล็อกที่เรียกตัวเองซ้ำเพื่อส่งออกอาร์เรย์ของตัวเลขที่ซ้อนกันอย่างถูกต้อง (เอาต์พุตเริ่มต้นใน Stax vectorizes อาร์เรย์ที่ซ้อนกันก่อนที่จะพิมพ์)

{                  }X    Store the code block in X
 {           m           Map each element in the list with block
  cc                     Make two copies of the element
    0+                   + 0. If the element is a scalar, nothing will change
                              If the element is an array, the element 0 will be appended
      =!{  }M            If the element has changed after the `0+` operation
                             Which means it is an array
         x!              Recursively execute the whole code block on the element

              ',*        Join the mapped elements with comma
                 :}      Bracerizes the final result

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