Créez une fonction ou un programme qui prend deux entrées:

• Une liste d'entiers à trier (moins de 20 éléments)
• Un entier positif N, indiquant le nombre de comparaisons à effectuer

La fonction doit s'arrêter et afficher la liste résultante d'entiers après les Ncomparaisons. Si la liste est entièrement triée avant que les Ncomparaisons soient faites, alors la liste triée doit être sortie.

L' algorithme de tri Bubble est bien connu, et je suppose que la plupart des gens le savent. Le pseudo-code et l'animation suivants (tous deux tirés de l'article Wikipedia lié) devraient fournir les détails nécessaires:

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

L'animation ci-dessous montre la progression:

Un exemple (tiré directement de l'article Wikipedia lié) montre les étapes du tri de la liste ( 5 1 4 2 8 ):

Premier passage

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.

Deuxième passe

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 )

Maintenant, le tableau est déjà trié, mais l'algorithme ne sait pas s'il est terminé. L'algorithme a besoin d'une passe entière sans aucun échange pour savoir qu'il est trié.

Troisième passage

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 )

Cas de test:

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

• Oui, les algorithmes de tri Bubble intégrés sont autorisés.
• Non, vous ne pouvez pas supposer uniquement des entiers positifs ou des entiers uniques.
• Le tri doit être dans l'ordre décrit ci-dessus. Vous ne pouvez pas commencer à la fin de la liste

Gelée , 25 octets

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

D'après ma réponse dans J.

Essayez-le en ligne!

Vérifiez le nombre de comparaisons.

Explication

Le lien d'aide modifie la liste à l'index [i-1, i]en la triant, ce qui produit le même résultat que la comparaison de tri à bulles.

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

Correction d'un bug et 1 octet enregistré grâce à @ 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")

La récursion n'est peut-être pas définitivement la meilleure approche, mais je m'en tiens à une boucle pour l'instant.

Essaye le:

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 octets

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

Exemple d'utilisation: [5,1,4,2,8] ! 5-> [1,4,2,5,8].

En fonction % yconserve une trace des éléments visités jusqu'à présent au cours de la passe en cours, xsont encore à examiner. aet bsont les deux suivants, à savoir les candidats à échanger. Si nous arrivons à la fin de la liste, nous commençons par le début: y%x = []%(y++x). Toutes les étapes sont stockées dans une liste où la fonction principale sélectionne le ne élément.

Edit: les versions précédentes ne fonctionnaient pas pour les listes d'éléments uniques, heureusement, la nouvelle version est encore plus courte.

Python 3, 77 74 octets

-3 octets grâce à @Maltysen (init jdans la déclaration)

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

Cas de test chez ideone

Utilise sortedpour effectuer chaque opération de comparaison et d'échange, mais il effectue un tri à bulles.

Ensembles j=0(l'index gauche), puis effectue ncomparer et échanges d'éléments de liste adjacents, de remise à zéro jà 0chaque fois que cette fenêtre sort des limites.

Le j*=j<len(l)-1se multipliera jpar False(c'est 0-à- dire ) à ce moment-là, tandis que toutes les autres fois il se multipliera jpar True(c'est-à-dire 1).

(Cela fonctionnera toujours pour une liste vide aussi.)

PowerShell v2 +, 135 129 octets

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

Donc. Beaucoup. Dollars.

( Enregistré six octets en réalisant que ce défi ne comprend pas le « gratuitement » l' optimisation de sauter le dernier élément (s) à chaque passage depuis qui est garanti triés, et fonctionne au lieu par un passage complet à chaque fois. Cela a déplacé la $a.countdans la forboucle et éliminé la $zvariable. )

Sorte de bulle droite, avec un endroit astucieux, faisant l'échange en une seule étape -
$a[$_],$a[$_+1]=$a[$_+1],$a[$_]

La logique de sortie est gérée via if(!--$n){$a;exit}

Cas de test

(Le tableau est affiché comme séparé par des espaces ici car le séparateur de champ de sortie par défaut pour la chaîne d'un tableau est un espace. La chaîne se produit parce que nous concaténons avec les étiquettes "$_ -> ".)

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 octets

Le programme reçoit l'entrée comme suit: d'abord N, puis le vecteur lui-même. Par exemple, si vous voulez v = [5 1 4 2 8]et n = 1, l'entrée qui va dans l' scanest 1 5 1 4 2 8. Donc, pour exécuter ce programme, vous exécutez la première ligne , alimentez les chiffres un par un dans la console , puis exécutez le reste (il s'agit d'une réponse REPL).

Ensuite, le code suivant fait l'affaire:

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

Tester:

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

Mise à jour: golf 1 octet dû à Vlo .

Pyth, 34 32 octets

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

Une traduction de la réponse Python de Jonathan Allan.

Essayez-le ici!

JavaScript (ES6), 82 80 79 octets

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)

Basé sur la réponse originale de @ ETHproduction. Edit: enregistré 2 octets grâce à @JonathanAllan. 1 octet enregistré grâce à @ edc65.

J , 62 60 octets

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

C'est un verbe qui prend deux arguments: le nombre de comparaisons sur le LHS et la liste des entiers sur le RHS. Il vérifie d'abord si la longueur de la liste est supérieure à un. Si ce n'est pas le cas, il renvoie la liste non modifiée, sinon il opère dessus en effectuant le nombre de comparaisons spécifié avant de renvoyer le résultat.

Usage

Pour le premier cas de test, des commandes supplémentaires sont utilisées pour formater plusieurs entrées / sorties. Le deuxième cas de test est représenté comme une entrée / sortie unique.

   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

Explication

Il est difficile d'écrire du code laconique en J qui utilise la mutabilité, donc je convertis le problème en réduction d'une liste sur un ensemble d'indices. Je pense que ce code est désordonné, donc je vais vous expliquer le travail de chaque phrase au lieu de chaque primitive. La première partie saisit la longueur de la liste et produit une plage. Ensuite, opérez sur chaque infixe de taille 2 pour émuler un passage de comparaisons.

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

Ce sont les premiers indices de chaque comparaison. Si 7 comparaisons sont en cours, remodelez-la pour obtenir la quantité souhaitée. J analyse de droite à gauche, donc son réduit de droite à gauche, comme plié à droite. Ajoutez la liste initiale et inversez-la.

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

Alternativement, la plage [0, 7) peut être créée et chaque valeur prise modulo la longueur de la liste moins 1 pour créer la même plage.

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

La dernière partie est un verbe qui prend une liste sur le RHS et un index sur le LHS qui marque l'indice de départ de la comparaison. Sélectionnez les deux éléments à partir de cet index, triez-les, puis rebranchez-les dans la liste et renvoyez-la.

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

Matlab, 93 91 octets

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

Enregistre 11 octets en omettant if l(i)>l(i+1);l(i:i+1)=l([i+1,i]), et à la place, trie simplement les deux éléments à chaque fois. Fonctionne pour les listes de longueur 1. Pourrait enregistrer un octet ou deux en utilisant Octavem-- opérateur , mais ce n'est pas beaucoup.

Enregistre deux octets supplémentaires en définissant n=numel(l)-1;, car alors je peux simplement faire à la while nplace de while n>1et i=mod(i,n)+1au lieu de i=mod(i,n-1)+1.

Pour mémoire, cette réponse a été écrite plusieurs heures après la création du défi.

Groovy (101 octets)

{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: Je n'avais pas besoin d'écrire ma propre fermeture de swap, groovy l'avait intégrée.
Essayez-la ici: https://groovyconsole.appspot.com/script/5104724189642752

Exemple de trace de sortie:

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]

Ancienne implémentation (122 octets)

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}

Essayez-le ici: https://groovyconsole.appspot.com/script/6316871066320896

php, 148 145 octets

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

Je ne suis pas très satisfait de la structure de la boucle, mais j'aime le commutateur de liste et cela fonctionne, donc je le poste quand même. php7.1 me permettrait d'économiser au moins 4 octets.

Avec un formatage plus agréable:

<?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 m'a rappelé de rejoindre, au lieu d'imploser.
note: doit être dans un fichier avec un nom de fichier à un seul caractère.

Rubis, 52 50 octets

Attendez ... non Ruby?

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