Tạo một chức năng hoặc chương trình có hai đầu vào:

• Danh sách các số nguyên sẽ được sắp xếp (dưới 20 phần tử)
• Một số nguyên dương, Ncho biết bạn nên thực hiện bao nhiêu so sánh

Hàm sẽ dừng và xuất danh sách các số nguyên kết quả sau khi Nso sánh. Nếu danh sách được sắp xếp đầy đủ trước khi Nso sánh được thực hiện, thì danh sách được sắp xếp sẽ được xuất ra.

Các Bubble sort thuật toán nổi tiếng, và tôi đoán hầu hết mọi người biết điều đó. Mã giả và hoạt hình sau đây (cả hai từ bài viết Wikipedia được liên kết) sẽ cung cấp các chi tiết cần thiết:

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

Hoạt hình dưới đây cho thấy sự tiến bộ:

Một ví dụ (lấy trực tiếp từ bài viết Wikipedia được liên kết) hiển thị các bước khi sắp xếp danh sách ( 5 1 4 2 8 )::

Đầu tiên vượt qua

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.

Đèo thứ hai

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 )

Bây giờ, mảng đã được sắp xếp, nhưng thuật toán không biết liệu nó đã được hoàn thành chưa. Thuật toán cần một lượt toàn bộ mà không có bất kỳ trao đổi nào để biết nó được sắp xếp.

Đèo thứ ba

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 )

Các trường hợp thử nghiệm:

Định dạng: 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

• Có, thuật toán sắp xếp bong bóng tích hợp được cho phép.
• Không, bạn không thể giả sử chỉ có số nguyên dương hoặc số nguyên duy nhất.
• Việc sắp xếp phải theo thứ tự được mô tả ở trên. Bạn không thể bắt đầu ở cuối danh sách

Thạch , 25 byte

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

Dựa trên câu trả lời của tôi trong J.

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

Xác nhận số lượng so sánh.

Giải trình

Liên kết trợ giúp sửa đổi danh sách tại chỉ mục [i-1, i]bằng cách sắp xếp nó tạo ra kết quả tương tự như so sánh sắp xếp bong bóng.

ḣ©ṫ-Ṣ®ṖṖ¤;;ṫḊ¥  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 byte

Sửa lỗi và lưu 1 byte nhờ @ 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")

Đệ quy có thể không chắc chắn không phải là cách tiếp cận tốt nhất, nhưng hiện tại tôi đang gắn bó với một vòng lặp.

Dùng thử:

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 byte

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

Ví dụ sử dụng: [5,1,4,2,8] ! 5-> [1,4,2,5,8].

Trong chức năng % ytheo dõi các yếu tố được truy cập cho đến nay trong quá trình hiện tại, xlà những yếu tố chưa được kiểm tra. avà blà hai người tiếp theo, tức là các ứng cử viên để trao đổi. Nếu chúng tôi đạt đến cuối danh sách, chúng tôi bắt đầu từ đầu : y%x = []%(y++x). Tất cả các bước được lưu trữ trong một danh sách trong đó hàm chính chọn nphần tử thứ.

Chỉnh sửa: các phiên bản trước không hoạt động cho danh sách thành phần đơn, may mắn là phiên bản mới thậm chí còn ngắn hơn.

Python 3, 77 74 byte

-3 byte nhờ @Maltysen (init jtrong khai báo)

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

Các trường hợp thử nghiệm tại ideone

Sử dụng sortedđể thực hiện từng thao tác so sánh và trao đổi, nhưng nó đang thực hiện sắp xếp bong bóng.

Bộ j=0(chỉ số trái), thực hiện sau đó nso sánh và giao dịch hoán đổi các hạng mục danh sách lân cận, đặt jđể 0bất cứ khi nào cửa sổ này đi ra ngoài giới hạn.

Ý j*=j<len(l)-1chí sẽ nhân jvới False(tức là 0) tại thời điểm đó, trong khi mọi lần khác nó sẽ nhân jvới True(tức là 1).

(Nó vẫn sẽ hoạt động cho một danh sách trống.)

PowerShell v2 +, 135 129 byte

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

Vì thế. Nhiều. USD.

( Đã lưu sáu byte bằng cách nhận ra rằng thử thách này không bao gồm tối ưu hóa "miễn phí" bỏ qua (các) phần tử cuối cùng trên mỗi lần vượt qua do được bảo đảm sắp xếp và thay vào đó chạy qua một lượt đầy đủ mỗi lần. Điều này đã chuyển $a.countvào forlặp và loại bỏ $zbiến. )

Sắp xếp bong bóng thẳng lên, với một điểm tiện lợi, thực hiện trao đổi trong một bước -
$a[$_],$a[$_+1]=$a[$_+1],$a[$_]

Logic thoát được xử lý thông qua if(!--$n){$a;exit}

Các trường hợp thử nghiệm

(Mảng được hiển thị dưới dạng phân tách không gian ở đây vì Dấu tách trường đầu ra mặc định để xâu chuỗi một mảng là khoảng trắng. Việc xâu chuỗi xảy ra do chúng tôi ghép với các nhãn "$_ -> ".)

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 byte

Chương trình nhận đầu vào như sau: đầu tiên N, sau đó là chính vector. Ví dụ, nếu bạn muốn v = [5 1 4 2 8]và n = 1, đầu vào đi vào scanlà 1 5 1 4 2 8. Vì vậy, để chạy chương trình này, bạn chạy dòng đầu tiên , cung cấp từng số một trong bảng điều khiển và sau đó chạy phần còn lại (đây là câu trả lời REPL).

Sau đó, đoạn mã sau thực hiện thủ thuật:

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

Kiểm tra:

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

Cập nhật: đánh gôn 1 byte nhờ Vlo .

Bình thường, 34 32 byte

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

Một bản dịch câu trả lời Python của Jonathan Allan.

Hãy thử nó ở đây!

JavaScript (ES6), 82 80 79 byte

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)

Dựa trên câu trả lời ban đầu của @ ETHproduction. Chỉnh sửa: Đã lưu 2 byte nhờ @Jonathan ALLan. Đã lưu 1 byte nhờ @ edc65.

J , 62 60 byte

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

Đây là một động từ có hai đối số: số lượng so sánh trên LHS và danh sách các số nguyên trên RHS. Đầu tiên, nó kiểm tra xem độ dài của danh sách nếu lớn hơn một. Nếu không, nó trả về danh sách không được sửa đổi, nếu không, nó sẽ hoạt động trên danh sách đó bằng cách thực hiện số lượng so sánh đã chỉ định trước khi trả về kết quả.

Sử dụng

Đối với trường hợp thử nghiệm đầu tiên, các lệnh bổ sung được sử dụng để định dạng nhiều đầu vào / đầu ra. Trường hợp thử nghiệm thứ hai được hiển thị dưới dạng đầu vào / đầu ra.

   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

Giải trình

Thật khó để viết mã terse trong J sử dụng khả năng biến đổi, vì vậy thay vào đó tôi chuyển vấn đề thành giảm danh sách trên một tập hợp các chỉ báo. Tôi nghĩ rằng mã này là lộn xộn vì vậy tôi sẽ hướng dẫn công việc của từng cụm từ thay vì từng nguyên thủy. Phần đầu tiên lấy chiều dài của danh sách và tạo ra một phạm vi. Sau đó, hoạt động trên mỗi infix cỡ 2 để mô phỏng một lượt so sánh.

   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│
└─┴─┴─┴─┘

Đây là những chỉ dẫn bắt đầu của mỗi so sánh. Nếu 7 so sánh đang được thực hiện, hãy định hình lại nó để có được số tiền mong muốn. J phân tích từ phải sang trái, do đó, nó giảm từ phải sang trái, như nếp gấp phải. Nối danh sách ban đầu và đảo ngược nó.

   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│
└─┴─┴─┴─┴─┴─┴─┴─────────┘

Ngoài ra, phạm vi [0, 7) có thể được thực hiện và mỗi giá trị được lấy modulo theo chiều dài của danh sách trừ đi 1 để tạo cùng một phạm vi.

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

Phần cuối cùng là một động từ lấy một danh sách trên RHS và một chỉ mục trên LHS đánh dấu chỉ số bắt đầu của so sánh. Chọn hai yếu tố bắt đầu từ chỉ mục đó, sắp xếp chúng và cắm chúng trở lại vào danh sách và trả về nó.

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

Matlab, 93 91 byte

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

Lưu 11 byte bằng cách bỏ qua if l(i)>l(i+1);l(i:i+1)=l([i+1,i]), và thay vào đó chỉ cần sắp xếp hai phần tử mỗi lần. Hoạt động cho danh sách độ dài 1. Có thể lưu một hoặc hai byte bằng m--toán tử của Octave , nhưng điều đó không nhiều.

Lưu thêm hai byte bằng cách thiết lập n=numel(l)-1;, bởi vì sau đó tôi chỉ có thể làm while nthay vì while n>1và i=mod(i,n)+1thay vì i=mod(i,n-1)+1.

Đối với hồ sơ, câu trả lời này đã được viết nhiều giờ sau khi thử thách được tạo ra.

Groovy (101 byte)

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

EDIT: Tôi không cần phải viết đóng cửa hoán đổi của riêng mình, Groovy đã tích hợp sẵn.
Hãy thử tại đây: https://groovyconsole.appspot.com/script/5104724189642752

Ví dụ đầu ra dấu vết:

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]

Thực hiện cũ (122 byte)

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}

Dùng thử tại đây: https://groovyconsole.appspot.com/script/6316871066320896

php, 148 145 byte

<?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);

Tôi không hài lòng lắm với cấu trúc vòng lặp nhưng tôi thích công tắc danh sách và nó hoạt động nên tôi vẫn đăng nó. php7.1 sẽ cho phép tôi lưu ít nhất 4 byte.

Với định dạng đẹp hơn:

<?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);

Chỉnh sửa: Jörg Hülsermann nhắc tôi tham gia, thay vì nổ tung.
lưu ý: cần phải ở trong một tệp có một tên tệp ký tự.

Ruby, 52 50 byte

Đợi ... không có Ruby?

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