Penyortiran gelembung sedang berlangsung

19

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:

masukkan deskripsi gambar di sini

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
Stewie Griffin
sumber
2
Jelas dan sangat masuk akal. Sayang sekali karena saya telah menemukan solusi yang benar-benar luar biasa untuk jenis gelembung cermin yang komentar ini tidak terlalu sempit untuk dikandung :)
Ton Hospel
Apakah daftar ini tidak kosong?
miles
Juga, akankah daftar memiliki ukuran lebih besar dari atau sama dengan 2? Saya perhatikan beberapa jawaban di bawah ini tidak berfungsi untuk daftar panjang 1 atau daftar kosong.
miles

Jawaban:

2

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
mil
sumber
9

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:

Produksi ETH
sumber
Saya berhasil golf versi rekursif Anda ke 82 byte terlalu: f=(a,m,n=0,_,b=a[n+1])=>b+.5?m?f(a,m-1,n+1,a[n]>b?a[a[n+1]=a[n],n]=b:0):a:f(a,m,0).
Neil
@Neil Wow, itu mengesankan! Anda dapat memposting itu sebagai milik Anda jika Anda mau.
ETHproduk
@Neil Anda dapat melakukan versi rekursif Anda di 80 juga, cukup hapus yang terakhir,0
Jonathan Allan
Coba 1/balih-alih b+.5memeriksaundefined
edc65
Baik, saran saya untuk 1 / b masih berlaku
edc65
7

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.

nimi
sumber
Apakah mungkin untuk menguji ini secara online? Saya tidak tahu apa-apa tentang Haskell, dan mendapatkan kesalahan ketika mencoba menempelkan ini langsung ke ide online. Saya kira saya kehilangan beberapa hal mendasar ...?
Stewie Griffin
Tambahkan f=sebelum baris kedua dari jawaban, kemudian tambahkan baris ketiga ke program yang berisi main=print(f [5,1,4,2,8] 5). Itu harus membuatnya runnable.
Lynn
@WeeingIfFirst: program lengkap
nimi
4

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

Jonathan Allan
sumber
1
Saya pikir Anda dapat menyimpan dengan menghapus plus dan pengaturan j = 0 pada params default lambda
Maltysen
1
juga, Anda tidak perlu mengatur ulang j, Anda dapat menggunakan%
Maltysen
@Maltysen sebenarnya saya tidak bisa menggunakan modulo aritmatika dan menyimpan byte, karena kita perlu menangani daftar panjang 1, ketika kita akan mendapatkan pembagian dengan kesalahan nol, menambahkan logika untuk menangani yang mendorong saya naik dalam byte.
Jonathan Allan
1
Bekerja dengan baik untuk semua test case, dan sedikit lebih pendek dari jawaban MATLAB saya. +1 =) Sayangnya, saya tidak dapat menggunakan teknik yang sama dengan evaldi MATLAB karena tugas inline.
Stewie Griffin
1
Diperbarui untuk memasukkan test case baru
Jonathan Allan
3

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
AdmBorkBork
sumber
3

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 .

Andreï Kostyrka
sumber
2
Ini tampaknya memerlukan hardcoding input sebagai variabel dan secara implisit menampilkan output melalui mekanisme REPL, yang tidak dapat diterima per daftar metode I / O yang dapat diterima .
Mego
@Mego Oke, saya memperbaikinya. Silakan lihat apakah sekarang ini sepenuhnya sesuai ...
Andreï Kostyrka
Sepertinya Anda dapat menghapus s = T pertama; dan masih memiliki output yang benar; ini menghemat 4 byte. EDIT: Faktanya, Anda dapat menghapus loop while () seluruhnya, dan cukup gunakan loop for (), mengganti s = T Anda dengan break, yang juga memungkinkan kami untuk menyingkirkan beberapa kurung kurawal. Ini menghasilkan: v = scan (); s = m = 0; untuk (i dalam 3: panjang (v)) {m = m + 1; jika (m> v [1]) istirahat; jika (v [i- 1]> v [i]); v [c (i-1, i)] = v [c (i, i-1)]; break}}; v [-1] Untuk total 117 byte.
rturnbull
@ Artbullull Versi Anda jauh lebih baik! Kudos untuk Anda.
Andreï Kostyrka
@rturnbull Kemana perginya komentar awal itu? Saran Anda untuk bermain golf sejauh 19 byte ... itu hanya menghilangkan loop ekstra yang sangat penting karena kinerja jenis gelembung adalah O (n²), sedangkan tanpa loop ekstra itu, panjangnya menjadi (n-1). Saya seharusnya sudah memeriksa ... Sekarang sudah diperbaiki dan berisi penjelasan bagaimana memberi makan di input! Apakah ini lebih baik dari sebelumnya?
Andreï Kostyrka
2

Pyth, 34 32 Bytes

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

Terjemahan dari jawaban Python Jonathan Allan's.

Coba di sini!

Steven H.
sumber
2

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.

Neil
sumber
2

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
mil
sumber
+1 yang mengesankan, sangat mengesankan.
Magic Octopus Urn
1

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.

Stewie Griffin
sumber
1

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

Guci Gurita Ajaib
sumber
Kesalahan ini untuk daftar dengan kurang dari dua item
Jonathan Allan
Di ponsel saya ... menambahkannya> = 0 di detik jika pernyataan memperbaiki masalah itu.
Magic Gurita Guci
Tampaknya gagal untuk daftar dengan input negatif juga. Misalnya test case kedua.
Stewie Griffin
Bekerja sekarang, saya menggunakan ponsel tadi malam sehingga saya tidak bisa melakukan pengeditan.
Magic Octopus Urn
1

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.

pengguna59178
sumber
php.net/manual/de/function.join.php alias implode
Jörg Hülsermann
$ t = $ a [$ i]; $ a [$ i] = $ a [$ i + 1]; $ a [$ i + 1] = $ t; lebih pendek daripada daftar ($ a [$ i], $ a [$ i + 1]) = [$ a [$ i + 1], $ a [$ i]]; dan saya tidak yakin jika bukan gema substr (implode ('', $ a), 5); ini $ a [1] = null; gema bergabung ('', $ a); alternatif yang lebih baik adalah.
Jörg Hülsermann
1
Sementara menggunakan variabel sementara lebih pendek 2 byte, itu juga beberapa pernyataan sehingga Anda perlu menggunakan 2 byte itu untuk melampirkan semuanya dalam kurung kurawal. Untuk $ a [1] = null Anda harus menghapusnya ($ a [0], $ a [1]) untuk menghindari spasi kosong dan nama file di awal.
user59178
1

Ruby, 52 50 byte

Tunggu ... tidak ada Ruby?

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