Cree una función o programa que tome dos entradas:

• Una lista de enteros que se ordenarán (menos de 20 elementos)
• Un entero positivo N, que dice cuántas comparaciones debe tomar

La función se detendrá y generará la lista resultante de enteros después de las Ncomparaciones. Si la lista está completamente ordenada antes de que Nse hagan las comparaciones, entonces la lista ordenada debería salir.

El algoritmo de clasificación de burbujas es bien conocido, y supongo que la mayoría de la gente lo sabe. El siguiente Pseudocódigo y animación (ambos del artículo vinculado de Wikipedia) deben proporcionar los detalles necesarios:

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

La siguiente animación muestra el progreso:

Un ejemplo (tomado directamente del artículo vinculado de Wikipedia) muestra los pasos al ordenar la lista ( 5 1 4 2 8 ):

Primer pase

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.

Segundo pase

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 )

Ahora, la matriz ya está ordenada, pero el algoritmo no sabe si está completa. El algoritmo necesita un pase completo sin ningún intercambio para saber que está ordenado.

Tercer pase

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 )

Casos de prueba:

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

• Sí, se permiten los algoritmos de clasificación de burbujas incorporados.
• No, no puede suponer solo enteros positivos o enteros únicos.
• La clasificación debe estar en el orden descrito anteriormente. No puedes comenzar al final de la lista

Jalea , 25 bytes

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

Basado en mi respuesta en J.

Pruébalo en línea!

Verifique el número de comparaciones.

Explicación

El enlace auxiliar modifica la lista en el índice [i-1, i]al ordenarla, lo que produce el mismo resultado que la comparación de clasificación de burbujas.

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

Corrección de errores y 1 byte guardado gracias a @ 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 recursión puede no ser definitivamente no es probablemente el mejor enfoque, pero me estoy quedando con un bucle por ahora.

Pruébalo:

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 bytes

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

Ejemplo de uso: [5,1,4,2,8] ! 5-> [1,4,2,5,8].

En la función % yrealiza un seguimiento de los elementos visitados hasta ahora durante el pase actual, xaún no se han examinado. ay bson los dos siguientes, es decir, los candidatos para intercambiar. Si se llega al final de la lista, comenzamos desde el principio: y%x = []%(y++x). Todos los pasos se almacenan en una lista donde la función principal selecciona el nelemento th.

Editar: las versiones anteriores no funcionaban para listas de elementos individuales, por suerte la nueva versión es aún más corta.

Python 3, 77 74 bytes

-3 bytes gracias a @Maltysen (init jen la declaración)

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

Casos de prueba en ideone

Suele sortedhacer cada operación de comparación e intercambio, pero está realizando una clasificación de burbujas.

Conjuntos j=0(el índice izquierdo), lleva a cabo luego ncomparar y permutas de elementos de la lista, al restablecer adyacentes ja 0cada vez que esta ventana sale.

Se j*=j<len(l)-1multiplicará jpor False(es decir 0) en ese punto, mientras que cada dos veces se multiplicará jpor True(es decir 1).

(Todavía funcionará para una lista vacía también).

PowerShell v2 +, 135 129 bytes

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

Entonces. Muchos. Dólares

( Ahorró seis bytes al darse cuenta de que este desafío no incluye la optimización "gratuita" de omitir los últimos elementos en cada pase, ya que está garantizado ordenado, y en su lugar ejecuta un pase completo cada vez. Esto movió $a.countel forloop y eliminó la $zvariable ) .

Tipo de burbuja recta, con un punto ingenioso, haciendo el intercambio en un solo paso:
$a[$_],$a[$_+1]=$a[$_+1],$a[$_]

La lógica existente se maneja a través de if(!--$n){$a;exit}

Casos de prueba

(La matriz se muestra como separada por espacios aquí porque el Separador de campo de salida predeterminado para encadenar una matriz es un espacio. La secuenciación ocurre porque estamos concatenando con las etiquetas "$_ -> ").

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 bytes

El programa recibe la entrada de la siguiente manera: primero N, luego el vector mismo. Por ejemplo, si quieres v = [5 1 4 2 8]y n = 1, la entrada que entra en el scanes 1 5 1 4 2 8. Entonces, para ejecutar este programa, ejecuta la primera línea , alimenta los números uno por uno en la consola y luego ejecuta el resto (esta es una respuesta REPL).

Entonces el siguiente código hace el truco:

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

Prueba:

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

Actualización: golfed 1 byte debido a Vlo .

Pyth, 34 32 bytes

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

Una traducción de la respuesta de Python de Jonathan Allan.

Pruébalo aquí!

JavaScript (ES6), 82 80 79 bytes

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)

Basado en la respuesta original de @ ETHproduction. Editar: Guardado 2 bytes gracias a @JonathanAllan. Guardado 1 byte gracias a @ edc65.

J , 62 60 bytes

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

Este es un verbo que toma dos argumentos: el número de comparaciones en el LHS y la lista de enteros en el RHS. Primero verifica si la longitud de la lista es mayor que uno. Si no es así, devuelve la lista sin modificar, de lo contrario, opera en ella realizando el número especificado de comparaciones antes de devolver el resultado.

Uso

Para el primer caso de prueba, los comandos adicionales se utilizan para formatear múltiples entradas / salidas. El segundo caso de prueba se muestra como entrada / salida única.

   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

Explicación

Es difícil escribir código conciso en J que use mutabilidad, por lo que, en cambio, convierto el problema en reducir una lista en un conjunto de indicaciones. Creo que este código es desordenado, así que explicaré el trabajo de cada frase en lugar de cada primitiva. La primera parte toma la longitud de la lista y produce un rango. Luego, opere en cada infijo de tamaño 2 para emular una pasada de comparaciones.

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

Estas son las indicaciones iniciales de cada comparación. Si se realizan 7 comparaciones, modifíquelo para obtener la cantidad deseada. J analiza de derecha a izquierda, por lo que se reduce de derecha a izquierda, como doblar a la derecha. Agregue la lista inicial y revertirla.

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

Alternativamente, se puede hacer el rango [0, 7) y tomar cada valor módulo a lo largo de la lista menos 1 para crear el mismo rango.

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

La última parte es un verbo que toma una lista en el RHS y un índice en el LHS que marca el índice de inicio de la comparación. Seleccione los dos elementos que comienzan en ese índice, ordénelos, vuelva a conectarlos a la lista y devuélvalos.

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

Matlab, 93 91 bytes

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

Ahorra 11 bytes al omitir if l(i)>l(i+1);l(i:i+1)=l([i+1,i]), y en su lugar solo ordena los dos elementos cada vez. Funciona para listas de longitud 1. Podría guardar un byte o dos usando el m--operador de Octave , pero eso no es mucho.

Guarda dos bytes más configurando n=numel(l)-1;, porque entonces puedo hacer en while nlugar de while n>1y en i=mod(i,n)+1lugar de i=mod(i,n-1)+1.

Para el registro, esta respuesta se escribió muchas horas después de que se creó el desafío.

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}

EDITAR: no necesitaba escribir mi propio cierre de intercambio, Groovy tenía esto incorporado.
Pruébalo aquí: https://groovyconsole.appspot.com/script/5104724189642752

Ejemplo de seguimiento de salida:

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]

Implementación anterior (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}

Pruébelo aquí: https://groovyconsole.appspot.com/script/6316871066320896

php, 148145 bytes

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

No estoy muy contento con la estructura del bucle, pero me gusta el cambio de lista y funciona, así que lo estoy publicando de todos modos. php7.1 me permitiría guardar al menos 4 bytes.

Con mejor formato:

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

Editar: Jörg Hülsermann me recordó unirme, en lugar de implosionar.
nota: debe estar en un archivo con un solo nombre de archivo de caracteres.

Ruby, 52 50 bytes

Espera ... no Ruby?

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