İki giriş alan bir işlev veya program oluşturun:

• Sıralanacak tam sayıların bir listesi (20 öğeden az)
• NKaç tane karşılaştırma yapmanız gerektiğini söyleyen pozitif bir tam sayı

Fonksiyon durmalı ve Nkarşılaştırmalar sonrasında ortaya çıkan tamsayılar listesini çıkarmalıdır . NKarşılaştırma yapılmadan önce liste tam olarak sıralandıysa , sıralı listenin çıktısı alınmalıdır.

Kabarcık sıralama algoritması iyi bilinen ve çoğu insan bunu biliyorum sanırım edilir. Aşağıdaki Sahte kod ve animasyon (her ikisi de bağlantılı Wikipedia makalesinden) gerekli ayrıntıları sağlamalıdır:

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

Aşağıdaki animasyon ilerlemeyi göstermektedir:

Bir örnek (doğrudan bağlantılı Wikipedia makalesinden alınmıştır) listeyi sıralama adımlarını gösterir ( 5 1 4 2 8 ):

İlk geçiş

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.

İkinci Geçiş

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 )

Şimdi, dizi zaten sıralanmıştır, ancak algoritma tamamlanıp tamamlanmadığını bilmemektedir. Algoritmanın sıralandığını bilmek için herhangi bir değişim olmadan bir tam geçişe ihtiyacı vardır.

Üçüncü Geçiş

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 )

Test senaryoları:

Biçim: 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

• Evet, yerleşik Bubble sıralama algoritmalarına izin verilir.
• Hayır, yalnızca pozitif tamsayıları veya benzersiz tamsayıları kabul edemezsiniz.
• Sıralama yukarıda açıklanan sırada olmalıdır. Listenin sonunda başlayamazsın

Jöle , 25 bayt

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

Benim dayanarak cevap J.

Çevrimiçi deneyin!

Karşılaştırma sayısını doğrulayın.

açıklama

Yardımcı bağlantı [i-1, i], kabarcık sıralama karşılaştırmasıyla aynı sonucu veren dizine göre listeyi değiştirir .

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

@ Edc65 sayesinde hata düzeltmesi ve 1 bayt kaydedildi

(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")

Özyineleme olmayabilir kesinlikle en iyi yaklaşım değildir, ama şimdilik bir döngü ile yapışıyorum.

Denemek:

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 bayt

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

Kullanım örneği: [5,1,4,2,8] ! 5-> [1,4,2,5,8].

Fonksiyonda % y, şimdiki geçiş sırasında şimdiye kadar ziyaret edilen öğeleri takip eder, xhenüz incelenmemiş olanlardır. ave bsıradaki ikisi, yani takas edilecek adaylar. Biz listesinin sonuna ulaşmak, biz baştan başlamak: y%x = []%(y++x). Tüm adımlar, ana işlevin nth öğesini seçtiği bir listede saklanır .

Düzenleme: önceki sürümler tek öğe listeleri için çalışmadı, neyse ki yeni sürüm daha da kısadır.

Python 3, 77 74 bayt

@Maltysen (-3 init jbeyannamesi) sayesinde -3 bayt

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

İdeone'de test senaryoları

sortedHer karşılaştırma ve takas işlemini yapmak için kullanır , ancak bir kabarcık sıralaması gerçekleştirir.

Kümeler j=0(sol işaret), sonra gerçekleştirdiği nkarşılaştırmak ve sıfırlama komşu liste öğelerin takasları jiçin 0bu pencere sınırların dışında gittiğinde.

j*=j<len(l)-1Çarpacaktır jtarafından False(yani 0her zaman oysa o çarpma olacak, bu noktada) jtarafından True(yani 1).

(Yine de boş bir liste için çalışacaktır.)

PowerShell v2 +, 1351212 bayt

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

Yani. Birçok. Dolar.

( Kaydedildi Bu meydan okuma olduğunu Onun yerine sıralanır ve garantili beri her geçişte son öğe (ler) atlama optimizasyonu "ücretsiz" tam geçitten her çalıştığında içermediğini gerçekleştirerek altı bayt. Bu hareket $a.countiçine fordöngü ve $zdeğişken ortadan kaldırıldı . )

Düz bir kabarcık sıralaması, bir şık nokta, bir adımda takas yapıyor -
$a[$_],$a[$_+1]=$a[$_+1],$a[$_]

Çıkış mantığı şu şekilde ele alınır: if(!--$n){$a;exit}

Test Durumları

(Bir diziyi dizgi yapmak için varsayılan Çıktı Alanı Ayırıcı bir boşluk olduğu için dizi burada boşlukla ayrılmış olarak gösterilir . Dizgi, etiketlerle birleştirme yaptığımız için gerçekleşir "$_ -> ".)

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 bayt

Program girişi aşağıdaki gibi alır: önce Nvektörün kendisi. Örneğin, istediğiniz, eğer v = [5 1 4 2 8]ve n = 1, gider girişi scanolduğunu 1 5 1 4 2 8. Yani bu programı çalıştırmak için, size ilk satırı çalıştırın , konsolda tek numaraları tek tek besleyebilir ve sonra kalanını çalıştırın (bu REPL cevaptır).

Sonra aşağıdaki kod hile yapar:

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

Ölçek:

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

Güncelleme: Vlo sayesinde 1 bayt golf .

Pyth, 34 32 Bayt

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

Jonathan Allan'ın Python cevabının çevirisi.

Burada deneyin!

JavaScript (ES6), 82 80 79 bayt

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'ın orijinal cevabına dayanmaktadır. Düzenleme: @JonathanAllan sayesinde 2 bayt kaydedildi. @ Edc65 sayesinde 1 bayt kaydedildi.

J , 62 60 bayt

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

Bu iki argüman alan bir fiildir: LHS'deki karşılaştırmaların sayısı ve RHS'deki tamsayıların listesi. İlk olarak listenin uzunluğunun birden fazla olup olmadığını kontrol eder. Değilse, listeyi değiştirmeden döndürür, aksi takdirde sonucu döndürmeden önce belirtilen sayıda karşılaştırma yaparak çalışır.

kullanım

İlk test durumunda, çoklu giriş / çıkış biçimlendirmek için ekstra komutları kullanılır. İkinci test durumu tek giriş / çıkış olarak gösterilir.

   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

açıklama

Değişkenliği kullanan J'de kısa kod yazmak zordur, bunun yerine problemi bir dizi göstergede bir listeyi azaltmaya dönüştürüyorum. Bu kod dağınık olduğunu düşünüyorum, bu yüzden her ilkel yerine her cümlenin işini ilerleyeceğim. İlk bölüm listenin uzunluğunu alır ve bir aralık oluşturur. Ardından, karşılaştırmaların bir geçişini taklit etmek için 2 boyutundaki her bir ek üzerinde işlem yapın.

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

Bunlar her karşılaştırmanın başlangıç ​​göstergeleridir. 7 karşılaştırma yapılıyorsa, istenen miktarı elde etmek için yeniden şekillendirin. J sağdan sola ayrışır, böylece sağa sola, sağa sola doğru azalır. İlk listeyi ekleyin ve ters çevirin.

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

Alternatif olarak, [0, 7) aralığı yapılabilir ve her bir değer, aynı aralığı oluşturmak için listenin eksi 1 uzunluğunda modulo olarak alınır.

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

Son bölüm, RHS'de bir liste ve karşılaştırmanın başlangıç ​​dizinini işaret eden LHS'de bir dizin alan bir fiildir. Bu dizinden başlayarak iki öğeyi seçin, sıralayın ve tekrar listeye takın ve geri döndürün.

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

Matlab, 93 91 bayt

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

Atlayarak 11 bayt tasarruf sağlar if l(i)>l(i+1);l(i:i+1)=l([i+1,i])ve bunun yerine iki öğeyi her seferinde sıralar. Uzunluk listeleri için çalışır 1. Octave m--operatörünü kullanarak bir veya iki bayt kaydedebilir , ancak bu çok fazla değildir.

Ayarlayarak iki bayt daha kaydeder n=numel(l)-1;, çünkü o zaman while nyerine while n>1ve i=mod(i,n)+1yerine yapabilirim i=mod(i,n-1)+1.

Kayıt için, bu cevap meydan okuma oluşturulduktan birkaç saat sonra yazılmıştır.

Harika (101 Bayt)

{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: Kendi takas kapatma yazmak gerek yoktu, groovy bu yerleşik.
Burada deneyin: https://groovyconsole.appspot.com/script/5104724189642752

Örnek Çıktı İzi:

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]

Eski Uygulama (122 Bayt)

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}

Burada deneyin: https://groovyconsole.appspot.com/script/6316871066320896

php, 148145 bayt

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

Döngü yapısı ile çok mutlu değilim ama liste anahtarını seviyorum ve işe yarıyor, bu yüzden yine de gönderiyorum. php7.1 en az 4 bayt kaydetmeme izin verir.

Daha güzel biçimlendirme ile:

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

Edit: Jörg Hülsermann implode yerine katılmamı hatırlattı.
not: tek karakterli dosya adına sahip bir dosyada olması gerekir.

Ruby, 52 50 bayt

Bekle ... Ruby yok mu?

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