สร้างฟังก์ชั่นหรือโปรแกรมที่รับสองอินพุต:

• รายการจำนวนเต็มที่จะเรียงลำดับ (น้อยกว่า 20 องค์ประกอบ)
• จำนวนเต็มบวกNบอกจำนวนการเปรียบเทียบที่คุณควรทำ

ฟังก์ชั่นจะหยุดและส่งออกรายการผลลัพธ์ของจำนวนเต็มหลังจากNการเปรียบเทียบ หากรายการถูกเรียงลำดับอย่างสมบูรณ์ก่อนทำการNเปรียบเทียบดังนั้นรายการที่เรียงควรถูกเอาท์พุท

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

procedure bubbleSort( A : list of sortable items )
   n = length(A)
   repeat 
     swapped = false
     for i = 1 to n-1 inclusive do
       /* if this pair is out of order */
       if A[i-1] > A[i] then    
         /* swap them and remember something changed */
         swap( A[i-1], A[i] )
         swapped = true
       end if
     end for
   until not swapped
end procedure

ภาพเคลื่อนไหวด้านล่างแสดงความคืบหน้า:

ตัวอย่าง (นำมาโดยตรงจากบทความ Wikipedia ที่เชื่อมโยง) แสดงขั้นตอนเมื่อเรียงลำดับรายการ( 5 1 4 2 8 )::

ผ่านก่อน

1: ( 5 1 4 2 8 ) ->  ( 1 5 4 2 8 ) // Here, algorithm compares the first two elements, 
                                   // and swaps since 5 > 1.
2: ( 1 5 4 2 8 ) ->  ( 1 4 5 2 8 ) // Swap since 5 > 4
3: ( 1 4 5 2 8 ) ->  ( 1 4 2 5 8 ) // Swap since 5 > 2
4: ( 1 4 2 5 8 ) ->  ( 1 4 2 5 8 ) // Now, since these elements are already in order 
                                   // (8 > 5), algorithm does not swap them.

รอบที่สอง

5: ( 1 4 2 5 8 ) ->  ( 1 4 2 5 8 )
6: ( 1 4 2 5 8 ) ->  ( 1 2 4 5 8 ) // Swap since 4 > 2
7: ( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )
8: ( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )

ตอนนี้อาร์เรย์ถูกเรียงลำดับแล้ว แต่อัลกอริทึมไม่ทราบว่ามันเสร็จสมบูรณ์หรือไม่ อัลกอริทึมนั้นต้องการหนึ่งรอบทั้งหมดโดยไม่มีการสลับใด ๆ เพื่อให้รู้ว่ามันถูกจัดเรียงแล้ว

รอบที่สาม

9: ( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )
10:( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )
11:( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )
12:( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )

กรณีทดสอบ:

รูปแบบ: Number of comparisons (N): List after N comparisons

Input list:
5  1  4  2  8
Test cases: 
1: 1  5  4  2  8
2: 1  4  5  2  8
3: 1  4  2  5  8
4: 1  4  2  5  8
5: 1  4  2  5  8
6: 1  2  4  5  8
10: 1  2  4  5  8
14: 1  2  4  5  8

Input list:
0: 15  18  -6  18   9  -7  -1   7  19  19  -5  20  19   5  15  -5   3  18  14  19
Test cases:
1: 15  18  -6  18   9  -7  -1   7  19  19  -5  20  19   5  15  -5   3  18  14  19
21: -6  15  18   9  -7  -1   7  18  19  -5  19  19   5  15  -5   3  18  14  19  20
41: -6   9  -7  15  -1   7  18  18  -5  19  19   5  15  -5   3  18  14  19  19  20
60: -6  -7  -1   9   7  15  18  -5  18  19   5  15  -5   3  18  14  19  19  19  20
61: -6  -7  -1   7   9  15  18  -5  18  19   5  15  -5   3  18  14  19  19  19  20
81: -7  -6  -1   7   9  15  -5  18  18   5  15  -5   3  18  14  19  19  19  19  20
119: -7  -6  -1  -5   7   9  15   5  15  -5   3  18  14  18  18  19  19  19  19  20
120: -7  -6  -1  -5   7   9  15   5  15  -5   3  18  14  18  18  19  19  19  19  20
121: -7  -6  -1  -5   7   9   5  15  15  -5   3  18  14  18  18  19  19  19  19  20
122: -7  -6  -1  -5   7   9   5  15  15  -5   3  18  14  18  18  19  19  19  19  20
123: -7  -6  -1  -5   7   9   5  15  -5  15   3  18  14  18  18  19  19  19  19  20
201: -7  -6  -5  -1  -5   3   5   7   9  14  15  15  18  18  18  19  19  19  19  20
221: -7  -6  -5  -5  -1   3   5   7   9  14  15  15  18  18  18  19  19  19  19  20

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

เยลลี่ 25 ไบต์

ḣ©ṫ-Ṣ®ṖṖ¤;;ṫḊ¥
JḊṁ¹³W¤;ç/

ตามคำตอบของฉันใน J

ลองออนไลน์!

ตรวจสอบจำนวนการเปรียบเทียบ

คำอธิบาย

ลิงค์ตัวช่วยแก้ไขรายการที่ดัชนี[i-1, i]โดยเรียงลำดับซึ่งสร้างผลลัพธ์เช่นเดียวกับการเปรียบเทียบการเรียงลำดับฟอง

ḣ©ṫ-Ṣ®ṖṖ¤;;ṫḊ¥  Helper link - Input: list A, index i
ḣ               Take the first i values
 ©              Save a copy of it
  ṫ-            Take the last two values
    Ṣ           Sort them
         ;      Append them to
     ®            Get the copy
      ṖṖ¤         Pop the last two values (Ṗ is pop)
          ;     Prepend it to
           ṫ      Take the last i values
            Ḋ¥    Dequeue - remove the head

JḊṁ¹³W¤;ç/  Input: list A and # of comparisons n
J           Enumerate the indices of A
 Ḋ          Dequeue - remove the head
  ṁ         Reshape it cyclically to length n
   ¹        Identity function (Just to avoid parsing rules)
       ;    Append it to
    ³         The list A
     W¤       Wrap it as an array
        ç/  Reduce from left to right using the helper link and return

JavaScript (ES6), 102 82 80 86 80 ไบต์

แก้ไขข้อผิดพลาดและบันทึก 1 ไบต์ด้วย @ edc65

(a,m)=>eval("for(i=0;m;a[j=i-1]>(b=a[i])?a[a[i]=a[j],j]=b:0)1/a[++i]?m--:i=0;a")

recursion อาจจะไม่ แน่นอนไม่น่าจะเป็นวิธีที่ดีที่สุด แต่ฉันติดกับห่วงสำหรับตอนนี้

ลองดูสิ:

f=(a,m)=>eval("for(i=0;m;a[j=i-1]>(b=a[i])?a[a[i]=a[j],j]=b:0)1/a[++i]?m--:i=0;a")

Enter your numbers:<br>
<input id=A rows=10 value="5 1 4 2 8"><br>
Enter the number of steps:<br>
<input type="number" min=0 id=B rows=10 value="1"><br>
<button onclick="C.innerHTML=f((A.value.match(/-?\d+/g)||[]).map(Number),B.value)">Run</button><br>
<pre id=C></pre>

Haskell, 83 82 81 ไบต์

y%x@(a:b:c)=(y++x):(y++[min a b])%(max a b:c)
y%x=[]%(y++x)
[x]!_=[x] 
x!n=[]%x!!n

ตัวอย่างการใช้งาน: ->[5,1,4,2,8] ! 5[1,4,2,5,8]

ในฟังก์ชั่น% yติดตามองค์ประกอบที่เข้าชมจนถึงในขณะที่ผ่านปัจจุบันxเป็นคนที่ยังไม่ได้ตรวจสอบ aและbเป็นสองต่อไปคือผู้สมัครที่จะแลกเปลี่ยน y%x = []%(y++x)ถ้าเรามาถึงจุดสิ้นสุดของรายการเราเริ่มต้นจากจุดเริ่มต้น: ขั้นตอนทั้งหมดจะถูกเก็บไว้ในรายการที่ฟังก์ชั่นหลักเลือกnองค์ประกอบที่

แก้ไข: เวอร์ชันก่อนหน้านี้ใช้ไม่ได้กับรายการองค์ประกอบเดียวโชคดีที่เวอร์ชันใหม่นั้นสั้นกว่านี้

Python 3, 77 74 ไบต์

-3 ไบต์ขอบคุณ @Maltysen (ริเริ่มjในการประกาศ)

lambda l,n,j=0:exec('j*=j<len(l)-1;l[j:j+2]=sorted(l[j:j+2]);j+=1;'*n)or l

กรณีทดสอบที่ideone

ใช้sortedเพื่อดำเนินการเปรียบเทียบและสลับแต่ละครั้ง แต่กำลังทำการเรียงลำดับฟอง

ตั้งค่าj=0(ดัชนีด้านซ้าย) จากนั้นทำการnเปรียบเทียบและสลับของรายการในรายการที่อยู่ติดกันรีเซ็ตjเป็น0เมื่อใดก็ตามที่หน้าต่างนี้ไม่มีขอบเขต

j*=j<len(l)-1จะคูณjโดยFalse(คือ0) ที่จุดนั้นในขณะที่ทุกครั้งที่อื่น ๆ ก็จะคูณjโดยTrue(คือ1)

(มันจะยังคงทำงานสำหรับรายการที่ว่างเปล่าด้วย)

PowerShell v2 +, 135 129 ไบต์

param($a,$n)for($s=1;$s){($s=0)..($a.count-2)|%{if($a[$_]-gt$a[$_+1]){$a[$_],$a[$_+1]=$a[$_+1],$a[$_];$s=1}if(!--$n){$a;exit}}}$a

ดังนั้น. จำนวนมาก ดอลลาร์

( ที่บันทึกไว้หกไบต์โดยตระหนักว่าความท้าทายนี้ไม่รวมถึง "ฟรี" การเพิ่มประสิทธิภาพของการกระโดดข้ามองค์ประกอบสุดท้าย (s) ในแต่ละผ่านมาตั้งแต่ที่รับประกันเรียงและแทนที่จะวิ่งผ่านผ่านเต็มรูปแบบในแต่ละครั้ง. นี้ย้าย$a.countเข้าไปในforวนรอบและกำจัด$zตัวแปร )

จัดเรียงฟองขึ้นตรงด้วยจุดที่ดีทำสลับในขั้นตอนเดียว -
$a[$_],$a[$_+1]=$a[$_+1],$a[$_]

ตรรกะที่มีอยู่จะถูกจัดการผ่าน if(!--$n){$a;exit}

กรณีทดสอบ

(อาเรย์แสดงเป็นช่องว่างคั่นที่นี่เนื่องจากตัวคั่นฟิลด์เอาต์พุตเริ่มต้นสำหรับการสร้างสตริงอาเรย์เป็นช่องว่างการสร้างสตริงเกิดขึ้นเนื่องจากเรากำลังเชื่อมต่อกับป้ายกำกับ"$_ -> ")

PS C:\Tools\Scripts\golfing> 1,2,3,4,5,6,10,14|%{"$_ -> "+(.\bubble-sorting-in-progress.ps1 @(5,1,4,2,8) $_)}
1 -> 1 5 4 2 8
2 -> 1 4 5 2 8
3 -> 1 4 2 5 8
4 -> 1 4 2 5 8
5 -> 1 4 2 5 8
6 -> 1 2 4 5 8
10 -> 1 2 4 5 8
14 -> 1 2 4 5 8

PS C:\Tools\Scripts\golfing> 1,21,41,60,61,81,119,120,121,122,123,201,221|%{"$_ -> "+(.\bubble-sorting-in-progress.ps1 @(15,18,-6,18,9,-7,-1,7,19,19,-5,20,19,5,15,-5,3,18,14,19) $_)}
1 -> 15 18 -6 18 9 -7 -1 7 19 19 -5 20 19 5 15 -5 3 18 14 19
21 -> -6 15 18 9 -7 -1 7 18 19 -5 19 19 5 15 -5 3 18 14 19 20
41 -> -6 9 -7 15 -1 7 18 18 -5 19 19 5 15 -5 3 18 14 19 19 20
60 -> -6 -7 -1 9 7 15 18 -5 18 19 5 15 -5 3 18 14 19 19 19 20
61 -> -6 -7 -1 7 9 15 18 -5 18 19 5 15 -5 3 18 14 19 19 19 20
81 -> -7 -6 -1 7 9 15 -5 18 18 5 15 -5 3 18 14 19 19 19 19 20
119 -> -7 -6 -1 -5 7 9 15 5 15 -5 3 18 14 18 18 19 19 19 19 20
120 -> -7 -6 -1 -5 7 9 15 5 15 -5 3 18 14 18 18 19 19 19 19 20
121 -> -7 -6 -1 -5 7 9 5 15 15 -5 3 18 14 18 18 19 19 19 19 20
122 -> -7 -6 -1 -5 7 9 5 15 15 -5 3 18 14 18 18 19 19 19 19 20
123 -> -7 -6 -1 -5 7 9 5 15 -5 15 3 18 14 18 18 19 19 19 19 20
201 -> -7 -6 -5 -1 -5 3 5 7 9 14 15 15 18 18 18 19 19 19 19 20
221 -> -7 -6 -5 -5 -1 3 5 7 9 14 15 15 18 18 18 19 19 19 19 20

R, 132 131 112 136 136 ไบต์

โปรแกรมรับอินพุตดังนี้: ก่อนNจากนั้นเวกเตอร์เอง ตัวอย่างเช่นถ้าคุณต้องการv = [5 1 4 2 8]และn = 1การป้อนข้อมูลที่จะเข้าสู่การเป็นscan 1 5 1 4 2 8ดังนั้นเพื่อที่จะเรียกใช้โปรแกรมนี้คุณเรียกใช้บรรทัดแรก , กินหมายเลขหนึ่งโดยหนึ่งในคอนโซลและจากนั้นเรียกใช้ส่วนที่เหลือ (นี่คือคำตอบที่ REPL)

จากนั้นรหัสต่อไปนี้จะหลอกลวง:

v=scan()
s=m=0
while(!s){s=T;for(i in 3:length(v)){m=m+1
if(m>v[1]){s=T;break}
if(v[i-1]>v[i]){v[c(i-1,i)]=v[c(i,i-1)];s=F}}}
cat(v[-1])

ทดสอบ:

Input: a vector with N first and the elements to be sorted next
1 5 1 4 2 8
5 5 1 4 2 8
14 5 1 4 2 8
60 15 18 -6 18  9 -7 -1  7 19 19 -5 20 19  5 15 -5  3 18 14 19

Output: 
1 5 4 2 8
1 4 2 5 8
1 2 4 5 8
-6 -7 -1  9  7 15 18 -5 18 19  5 15 -5  3 18 14 19 19 19 20

ปรับปรุง: แข็งแรงเล่นกอล์ฟ 1 ไบต์เนื่องจากVLO

Pyth, 34 32 ไบต์

AQVH=*<ZtlGZ=GsXJcG,Zh=hZ1ShtJ;G

คำแปลของ Jonathan Allan Python เป็นคำตอบ

ลองที่นี่!

JavaScript (ES6), 82 80 79 ไบต์

f=(a,m,n=0,_,b=a[n+1])=>1/b?m?f(a,m-1,n+1,a[n]>b?a[a[n+1]=a[n],n]=b:0):a:f(a,m)

ตามคำตอบดั้งเดิมของ @ ETHproduction แก้ไข: บันทึก 2 ไบต์ขอบคุณ @JonathanAllan บันทึกแล้ว 1 ไบต์ขอบคุณ @ edc65

J , 62 60 ไบต์

>@([:({.,(2/:~@{.}.),]}.~2+[)&.>/]|.@;<:@#@]<@|i.@[)^:(]1<#)

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

การใช้

สำหรับกรณีทดสอบครั้งแรกคำสั่งพิเศษถูกใช้เพื่อจัดรูปแบบอินพุต / เอาต์พุตหลายรายการ กรณีทดสอบที่สองแสดงเป็นอินพุต / เอาต์พุตเดียว

   f =: >@([:({.,(2/:~@{.}.),]}.~2+[)&.>/]|.@;<:@#@]<@|i.@[)^:(]1<#)
   1 2 3 4 5 6 10 14 ([;f)"0 1 ] 5 1 4 2 8
┌──┬─────────┐
│1 │1 5 4 2 8│
├──┼─────────┤
│2 │1 4 5 2 8│
├──┼─────────┤
│3 │1 4 2 5 8│
├──┼─────────┤
│4 │1 4 2 5 8│
├──┼─────────┤
│5 │1 4 2 5 8│
├──┼─────────┤
│6 │1 2 4 5 8│
├──┼─────────┤
│10│1 2 4 5 8│
├──┼─────────┤
│14│1 2 4 5 8│
└──┴─────────┘
   1 f 15 18 _6 18 9 _7 _1 7 19 19 _5 20 19 5 15 _5 3 18 14 19
15 18 _6 18 9 _7 _1 7 19 19 _5 20 19 5 15 _5 3 18 14 19
   123 f 15 18 _6 18 9 _7 _1 7 19 19 _5 20 19 5 15 _5 3 18 14 19
_7 _6 _1 _5 7 9 5 15 _5 15 3 18 14 18 18 19 19 19 19 20
   221 f 15 18 _6 18 9 _7 _1 7 19 19 _5 20 19 5 15 _5 3 18 14 19
_7 _6 _5 _5 _1 3 5 7 9 14 15 15 18 18 18 19 19 19 19 20

คำอธิบาย

มันยากที่จะเขียนรหัส terse ใน J ที่ใช้ความไม่แน่นอนดังนั้นฉันจึงแปลงปัญหาเป็นลดรายการในชุดของตัวบ่งชี้ ฉันคิดว่ารหัสนี้ยุ่งดังนั้นฉันจะแนะนำงานของแต่ละวลีแทนที่จะเป็นแบบดั้งเดิม ส่วนแรกคว้าความยาวของรายการและสร้างช่วง จากนั้นดำเนินการในแต่ละมัดของขนาด 2 เพื่อเลียนแบบการเปรียบเทียบหนึ่งรอบ

   i. # 5 1 4 2 8
0 1 2 3 4
   2 <\ i. # 5 1 4 2 8
┌───┬───┬───┬───┐
│0 1│1 2│2 3│3 4│
└───┴───┴───┴───┘
   2 <@{.\ i. # 5 1 4 2 8
┌─┬─┬─┬─┐
│0│1│2│3│
└─┴─┴─┴─┘

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

   7 $ 2 <@{.\ i. # 5 1 4 2 8
┌─┬─┬─┬─┬─┬─┬─┐
│0│1│2│3│0│1│2│
└─┴─┴─┴─┴─┴─┴─┘
   |. 5 1 4 2 8 ; 7 $ 2 <@{.\ i. # 5 1 4 2 8
┌─┬─┬─┬─┬─┬─┬─┬─────────┐
│2│1│0│3│2│1│0│5 1 4 2 8│
└─┴─┴─┴─┴─┴─┴─┴─────────┘

อีกทางเลือกหนึ่งคือช่วง [0, 7) และแต่ละค่าที่นำมาโมดูโลจะมีความยาวของรายการลบ 1 เพื่อสร้างช่วงเดียวกัน

   (<: # 5 1 4 2 8) <@| i. 7
┌─┬─┬─┬─┬─┬─┬─┐
│0│1│2│3│0│1│2│
└─┴─┴─┴─┴─┴─┴─┘

ส่วนสุดท้ายคือคำกริยาที่ใช้รายการบน RHS และดัชนีบน LHS ซึ่งทำเครื่องหมายดัชนีเริ่มต้นของการเปรียบเทียบ เลือกองค์ประกอบสองรายการที่เริ่มต้นที่ดัชนีเรียงลำดับและเสียบกลับเข้าไปในรายการและส่งคืน

   > ({.,(2/:~@{.}.),]}.~2+[)&.>/ |. 5 1 4 2 8 ; 7 $ 2 <@{.\ i. # 5 1 4 2 8
1 2 4 5 8

Matlab, 93 91 ไบต์

function l=f(l,m)
n=numel(l)-1;i=0;while n&m;i=mod(i,n)+1;m=m-1;l(i:i+1)=sort(l(i:i+1));end

บันทึก 11 ไบต์โดยละเว้นif l(i)>l(i+1);l(i:i+1)=l([i+1,i])และเพียงเรียงลำดับสององค์ประกอบทุกครั้ง ใช้งานได้กับรายการความยาว 1. สามารถบันทึกหนึ่งหรือสองไบต์โดยใช้m--โอเปอเรเตอร์ของ Octave แต่นั่นไม่มากนัก

บันทึกไบต์ที่สองมากขึ้นโดยการตั้งค่าn=numel(l)-1;แล้วเพราะฉันสามารถทำwhile nแทนwhile n>1และแทนi=mod(i,n)+1i=mod(i,n-1)+1

สำหรับบันทึกคำตอบนี้ถูกเขียนขึ้นเป็นเวลาหลายชั่วโมงหลังจากการท้าทายถูกสร้างขึ้น

Groovy (101 ไบต์)

{l,n->(l.size()..0).each{i->(0..i-2).each{if(l[it]>l[it+1] && n>0 && it>-1){l.swap(it,it+1)};n--}};l}

แก้ไข: ฉันไม่จำเป็นต้องเขียนการปิด swap ของตัวเอง Groovy มีสิ่งนี้มาด้วย
ลองที่นี่: https://groovyconsole.appspot.com/script/5104724189642752

ตัวอย่างผลลัพธ์การสืบค้นกลับ:

4:[1, 5, 4, 2, 8]
3:[1, 4, 5, 2, 8]
2:[1, 4, 2, 5, 8]
1:[1, 4, 2, 5, 8]
0:[1, 4, 2, 5, 8] - Locks in the final answer.
-1:[1, 4, 2, 5, 8]
-2 (Return):[1, 4, 2, 5, 8]

การใช้งานแบบเก่า (122 ไบต์)

m={l,n->s={x,y->t=l[x];l[x]=l[y];l[y]=t};((l.size()-2)..2).each{i->(0..i).each{if(l[it]>l[it+1] && n){s(it,it+1)};n--}};l}

ลองที่นี่: https://groovyconsole.appspot.com/script/6316871066320896

php, 148 145 ไบต์

<?php for($i=2,$a=$argv;$a[1]--;$i=$i==count($a)-2?2:$i+1)if($a[$i]>$a[$i+1])list($a[$i],$a[$i+1])=[$a[$i+1],$a[$i]];echo substr(join(' ',$a),5);

ฉันไม่ค่อยพอใจกับโครงสร้างลูป แต่ฉันชอบสวิตช์รายการและใช้งานได้ดังนั้นฉันจึงโพสต์ไว้ php7.1 จะอนุญาตให้ฉันบันทึกอย่างน้อย 4 ไบต์

ด้วยการจัดรูปแบบที่ดีกว่า:

<?php 
for($i=2,$a=$argv;$a[1]--;$i=$i==count($a)-2?2:$i+1)
  if($a[$i]>$a[$i+1])
    list($a[$i],$a[$i+1])=[$a[$i+1],$a[$i]];
echo substr(join(' ',$a),5);

แก้ไข: JörgHülsermannทำให้ฉันนึกถึงการเข้าร่วมแทนที่จะเป็นการระเบิด
หมายเหตุ: ต้องอยู่ในไฟล์ที่มีชื่อไฟล์อักขระเดียว

Ruby, 52 50 ไบต์

เดี๋ยวก่อน ... ไม่มีทับทิม?

->l,n{n.times{|a|l[s=a%~-l.size,2]=l[s,2].sort};l}