Buat fungsi atau program yang mengambil dua input:

• Daftar bilangan bulat yang harus diurutkan (kurang dari 20 elemen)
• Bilangan bulat positif N,, mengatakan berapa banyak perbandingan yang harus Anda ambil

Fungsi harus berhenti, dan mengeluarkan daftar bilangan bulat setelah Nperbandingan. Jika daftar sepenuhnya diurutkan sebelum Nperbandingan dibuat, maka daftar yang diurutkan harus dikeluarkan.

The Bubble sort algoritma terkenal, dan saya kira kebanyakan orang tahu itu. Kode Pseudo dan animasi berikut (keduanya dari artikel Wikipedia yang terhubung) harus memberikan perincian yang diperlukan:

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

Animasi di bawah ini menunjukkan progres:

Contoh (diambil langsung dari artikel Wikipedia yang terhubung) menunjukkan langkah-langkah saat mengurutkan daftar ( 5 1 4 2 8 )::

Pass Pertama

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.

Pass Kedua

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 )

Sekarang, array sudah diurutkan, tetapi algoritma tidak tahu apakah sudah selesai. Algoritme membutuhkan satu pass penuh tanpa swap apa pun untuk mengetahuinya.

Lulus Ketiga

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 )

Kasus uji:

Format: 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

• Ya, algoritme semacam gelembung bawaan diizinkan.
• Tidak, Anda tidak dapat mengasumsikan hanya bilangan bulat positif, atau bilangan bulat unik.
• Penyortiran harus dalam urutan yang dijelaskan di atas. Anda tidak dapat memulai di akhir daftar

Jelly , 25 byte

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

Berdasarkan jawaban saya di J.

Cobalah online!

Verifikasi jumlah perbandingan.

Penjelasan

Tautan pembantu mengubah daftar pada indeks [i-1, i]dengan mengurutkannya yang menghasilkan hasil yang sama dengan perbandingan jenis gelembung.

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

Perbaikan bug dan 1 byte disimpan berkat @ 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")

Rekursi mungkin tidak pasti bukan mungkin merupakan pendekatan terbaik, tapi saya bertahan dengan sebuah loop untuk saat ini.

Cobalah:

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

Contoh penggunaan: [5,1,4,2,8] ! 5-> [1,4,2,5,8].

Berfungsi % ymelacak elemen yang dikunjungi sejauh ini saat pass, xadalah yang belum diperiksa. adan badalah dua berikutnya, yaitu kandidat untuk bertukar. Jika kita mencapai akhir dari daftar, kita mulai dari awal: y%x = []%(y++x). Semua langkah disimpan dalam daftar di mana fungsi utama mengambil nelemen th.

Sunting: versi sebelumnya tidak berfungsi untuk daftar elemen tunggal, untungnya versi baru bahkan lebih pendek.

Python 3, 77 74 byte

-3 byte terima kasih kepada @Maltysen (init jdalam deklarasi)

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

Uji kasus di ideone

Menggunakan sorteduntuk melakukan masing-masing operasi perbandingan dan swap, tetapi melakukan semacam gelembung.

Set j=0 (indeks kiri), kemudian melakukan nbandingkan dan bertukar item daftar yang berdekatan, ulang jke 0setiap kali jendela ini keluar dari batas.

The j*=j<len(l)-1akan berkembang biak jdenganFalse (yaitu 0) pada saat itu, sedangkan setiap kali lain itu akan kalikan jdengan True(yaitu 1).

(Ini juga akan berfungsi untuk daftar kosong.)

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

Begitu. Banyak. Dolar

( Disimpan enam byte dengan menyadari bahwa tantangan ini tidak termasuk "gratis" optimasi melewatkan elemen terakhir (s) pada setiap lulus karena yang ini dijamin diurutkan, dan sebaliknya berjalan melalui lulus penuh setiap kali. Ini pindah $a.countke forlingkaran dan menghilangkan $zvariabel. )

Jenis gelembung lurus, dengan satu tempat bagus, melakukan pertukaran dalam satu langkah -
$a[$_],$a[$_+1]=$a[$_+1],$a[$_]

Logika keluar ditangani melalui if(!--$n){$a;exit}

Uji Kasus

(Array ditampilkan sebagai ruang-dipisahkan di sini karena Pemisah Bidang Output default untuk merangkaikan array adalah spasi. Stringisasi terjadi karena kita sedang menyatu dengan label "$_ -> ".)

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

Program menerima input sebagai berikut: pertama N, kemudian vektor itu sendiri. Misalnya, jika Anda mau v = [5 1 4 2 8]dan n = 1, input yang masuk ke scanis 1 5 1 4 2 8. Jadi untuk menjalankan program ini, Anda menjalankan baris pertama , beri makan angka satu per satu di konsol , dan kemudian jalankan sisanya (ini adalah jawaban REPL).

Kemudian kode berikut melakukan trik:

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

Uji:

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

Pembaruan: golf 1 byte karena Vlo .

Pyth, 34 32 Bytes

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

Terjemahan dari jawaban Python Jonathan Allan's.

Coba di sini!

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)

Berdasarkan jawaban asli @ ETHproduction. Sunting: Disimpan 2 byte berkat @JonathanAllan. Disimpan 1 byte berkat @ edc65.

J , 62 60 byte

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

Ini adalah kata kerja yang mengambil dua argumen: jumlah perbandingan pada LHS dan daftar bilangan bulat pada RHS. Pertama, periksa apakah panjang daftar jika lebih dari satu. Jika tidak, ia mengembalikan daftar yang tidak dimodifikasi, jika tidak beroperasi dengan melakukan perbandingan jumlah yang ditentukan sebelum mengembalikan hasilnya.

Pemakaian

Untuk kasus uji pertama, perintah ekstra digunakan untuk memformat beberapa input / output. Kasing uji kedua ditampilkan sebagai input / output tunggal.

   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

Penjelasan

Sulit untuk menulis kode singkat dalam J yang menggunakan mutability, jadi alih-alih saya mengubah masalah menjadi mengurangi daftar pada serangkaian indeks. Saya pikir kode ini berantakan sehingga saya akan melakukan pekerjaan dari setiap frase, bukan masing-masing primitif. Bagian pertama meraih panjang daftar dan menghasilkan kisaran. Kemudian, operasikan pada setiap infiks ukuran 2 untuk meniru satu lintasan perbandingan.

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

Ini adalah indeks awal dari setiap perbandingan. Jika 7 perbandingan dilakukan, bentuk ulang untuk mendapatkan jumlah yang diinginkan. J mem-parsing kanan ke kiri, sehingga mengurangi kanan ke kiri, seperti flip-kanan. Tambahkan daftar awal dan balikkan.

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

Atau, kisaran [0, 7) dapat dibuat dan setiap nilai diambil modulo panjang daftar minus 1 untuk membuat rentang yang sama.

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

Bagian terakhir adalah kata kerja yang mengambil daftar pada RHS dan indeks pada LHS yang menandai indeks awal perbandingan. Pilih dua elemen mulai dari indeks itu, urutkan, dan pasang kembali ke dalam daftar dan kembalikan.

   > ({.,(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

Menghemat 11 byte dengan menghilangkan if l(i)>l(i+1);l(i:i+1)=l([i+1,i]), dan alih-alih hanya mengurutkan kedua elemen setiap kali. Berfungsi untuk daftar panjang 1. Bisa menghemat satu atau dua byte menggunakan m--operator Oktaf , tapi itu tidak banyak.

Menghemat dua byte lebih banyak dengan mengatur n=numel(l)-1;, karena dengan begitu saya bisa melakukan while nalih - alih while n>1, dan i=mod(i,n)+1bukannya i=mod(i,n-1)+1.

Sebagai catatan, jawaban ini ditulis berjam-jam setelah tantangan dibuat.

Groovy (101 Bytes)

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

SUNTING: Saya tidak perlu menulis penutupan swap saya sendiri, asyik ini sudah terpasang.
Coba di sini: https://groovyconsole.appspot.com/script/5104724189642752

Contoh Jejak Keluaran:

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]

Implementasi Lama (122 Bytes)

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}

Cobalah di sini: 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);

Saya tidak terlalu senang dengan struktur loop tetapi saya suka saklar daftar dan itu berfungsi jadi saya tetap mempostingnya. php7.1 akan memungkinkan saya untuk menyimpan setidaknya 4 byte.

Dengan pemformatan yang lebih bagus:

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

Sunting: Jörg Hülsermann mengingatkan saya untuk bergabung, bukannya meledak.
catatan: harus dalam file dengan nama file karakter tunggal.

Ruby, 52 50 byte

Tunggu ... tidak ada Ruby?

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