19

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

code-golf sorting Stewie Griffin
fuente

2

Claro y perfectamente razonable. Es una pena ya que descubrí una solución realmente maravillosa para el tipo de burbuja espejada que este comentario no es demasiado estrecho para contener :)

Ton Hospel

¿La lista no estará vacía?

millas

Además, ¿la lista tendrá un tamaño mayor o igual a 2? Noté que algunas respuestas a continuación no funcionan para listas de longitud 1 o listas vacías.

millas

2

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

millas
fuente

9

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:

Mostrar fragmento de código

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>

Expandir fragmento

ETHproducciones
fuente

Logré campo de la versión recursiva hasta 82 bytes demasiado: 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, ¡eso es impresionante! Puede publicarlo como propio si lo desea.

ETHproductions

@Neil También puedes hacer tu versión recursiva en 80, solo quita la última,0

Jonathan Allan el

Intente en 1/blugar de b+.5buscarundefined

edc65

Bien, mi sugerencia para 1 / b todavía se mantiene

edc65

7

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.

nimi
fuente

¿Es posible probar esto en línea? No sé nada sobre Haskell, y recibo errores al intentar pegar esto directamente en una ide en línea. Supongo que me faltan algunas cosas básicas ...?

Stewie Griffin

Agregue f=antes de la segunda línea de la respuesta, luego agregue una tercera línea al programa que contiene main=print(f [5,1,4,2,8] 5). Eso debería hacerlo ejecutable.

Lynn

@WeeingIfFirst: programa completo

nimi

4

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

Jonathan Allan
fuente

1

Creo que puede ahorrar eliminando el signo más y estableciendo j = 0 en los parámetros predeterminados lambda

Maltysen

1

Además, no necesita reiniciar j, puede usar%

Maltysen

@Maltysen en realidad no puedo usar el módulo aritmético y guardar bytes, ya que necesitamos manejar una lista de longitud 1, cuando obtendríamos un error de división por cero, agregando la lógica para manejar que me empuja hacia arriba en bytes.

Jonathan Allan

1

Funciona bien para todos los casos de prueba, y es bastante más corto que mi respuesta de MATLAB. +1 =) Desafortunadamente, no puedo usar la misma técnica con evalMATLAB debido a las asignaciones en línea.

Stewie Griffin

1

Actualizado para incluir nuevos casos de prueba

Jonathan Allan

3

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

AdmBorkBork
fuente

3

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 .

Andreï Kostyrka
fuente

2

Esto parece requerir codificar las entradas como variables y mostrar implícitamente la salida a través de un mecanismo REPL, que no es accesible según nuestra lista de métodos de E / S aceptables .

Mego

@Mego Ok, lo arreglé. Por favor, vea si ahora es totalmente compatible ...

Andreï Kostyrka

Parece que puedes eliminar el primer s = T; y todavía tiene salida correcta; Esto le ahorra 4 bytes. EDITAR: De hecho, puede eliminar el bucle while () por completo, y simplemente usar el bucle for (), reemplazando su s = T con break, lo que también nos permite deshacernos de algunas llaves. Esto produce: v = scan (); s = m = 0; for (i en 3: length (v)) {m = m + 1; if (m> v [1]) break; if (v [i- 1]> v [i]); v [c (i-1, i)] = v [c (i, i-1)]; break}}; v [-1] Para un total de 117 bytes.

rturnbull

@rturnbull ¡Tu versión es mucho mejor! Felicitaciones a usted.

Andreï Kostyrka

@rturnbull ¿A dónde fueron esos primeros comentarios? Su sugerencia de jugar golf a 19 bytes de distancia ... simplemente eliminó ese bucle adicional que era esencial porque el rendimiento del ordenamiento de burbujas es O (n²), mientras que sin ese bucle adicional, se hace (n-1) largo. Debería haber verificado ... ¡Ahora está arreglado y contiene una explicación sobre cómo alimentar la entrada! ¿Es mejor que antes?

Andreï Kostyrka

2

Pyth, 34 32 bytes

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

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

Pruébalo aquí!

Steven H.
fuente

2

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.

Neil
fuente

2

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

millas
fuente

Impresionante, muy impresionante +1.

Magic Octopus Urn

1

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.

Stewie Griffin
fuente

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}

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

Urna de pulpo mágico
fuente

Esto es un error para las listas con menos de dos elementos

Jonathan Allan el

En mi móvil ... agregándolo> = 0 en la segunda sentencia if soluciona ese problema.

Urna de pulpo mágico

Parece fallar también para las listas con entrada negativa. Por ejemplo, el segundo caso de prueba.

Stewie Griffin

Funciona ahora, estaba en un móvil anoche, así que no pude hacer las ediciones necesarias.

Magic Octopus Urn

1

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.

usuario59178
fuente

php.net/manual/de/function.join.php alias de implode

Jörg Hülsermann

$ t = $ a [$ i]; $ a [$ i] = $ a [$ i + 1]; $ a [$ i + 1] = $ t; es más corto que la lista ($ a [$ i], $ a [$ i + 1]) = [$ a [$ i + 1], $ a [$ i]]; y no estoy seguro si en lugar de echo substr (implode ('', $ a), 5); este $ a [1] = nulo; echo join ('', $ a); La mejor alternativa es.

Jörg Hülsermann

1

Si bien el uso de la variable temporal es 2 bytes más corto, también es múltiples declaraciones, por lo que debe usar esos 2 bytes para encerrar todo en llaves. Para $ a [1] = nulo, realmente necesitaría desarmar ($ a [0], $ a [1]) para evitar espacios en blanco y el nombre del archivo al principio.

user59178

1

Ruby, 52 50 bytes

Espera ... no Ruby?

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

GB
fuente

Clasificación de burbujas en progreso

Casos de prueba:

Respuestas:

Jalea , 25 bytes

Explicación

JavaScript (ES6), 102 82 80 86 80 bytes

Pruébalo:

Haskell, 83 82 81 bytes

Python 3, 77 74 bytes

PowerShell v2 +, 135 129 bytes

Casos de prueba

R, 132 131 112 136 bytes

Pyth, 34 32 bytes

JavaScript (ES6), 82 80 79 bytes

J , 62 60 bytes

Uso

Explicación

Matlab, 93 91 bytes

Groovy (101 bytes)

Ejemplo de seguimiento de salida:

Implementación anterior (122 bytes)

php, 148145 bytes

Ruby, 52 50 bytes