La pregunta

Dado un conjunto de 9 números, m[]que contiene solo los números del 1 al 9 en un orden aleatorio, sin que haya dos números iguales, cree un programa en cualquier idioma que reorganice el número para que esté en orden numérico (1, 2, 3, etc. etc.) solo cambiando dos números que están uno al lado del otro (es decir, 1, 3, 2 → 1, 2, 3).

Reglas

• Solo puede modificar el conjunto cambiando dos números que están uno al lado del otro
• Los números finales (del 1 al 9 en orden) deben estar contenidos en m[]
• Puedes usar cualquier idioma que quieras
• La respuesta con la menor cantidad de bytes gana

Editar:

Su código no tiene que imprimir la salida, pero la matriz reorganizada debe estar en m[].

CJam, 15 bytes

q~A{{a+$~}*]}*p

Cómo funciona:

q~                     e# Read the CJam styled input array (For ex. [1 3 4 2 5 6 8 7 9])
  A{        }*         e# Run the loop 10 times. This is enough times for a 10 length
                       e# input array in a bubble sort
    {    }*            e# reduce
     a+$~              e# Rearrange the pair so that they are sorted
           ]           e# After each loop, wrap the numbers back into the array
              p        e# Print the array after the loops are done

Pruébalo en línea aquí

Mathematica, 38 bytes

#//.{a___,b_,c_,d___}/;b>c:>{a,c,b,d}&

Esta es una función sin nombre que toma una matriz, que aplica una regla de reemplazo hasta que ya no se pueda encontrar el patrón. El patrón es una lista que tiene dos elementos consecutivos byc dónde b > c, y la regla dice que intercambie by, de lo ccontrario, deje la matriz intacta.

Aquí hay mucho azúcar sintáctico, pero el código es realmente muy legible si conoces un poco de Mathematica:

# //. {a___,b_,c_,d___} /; b>c :> {a,c,b,d} &
^  ^     ^   ^          ^      ^            ^
|  |     |   |          |      |            |
|  |     |   | Declares an unnamed function |
|  |     |   |          |      |
| The function's argument      |
   |     |   |          |      |
   | Replace while possible... |
         |   |          |      |
         | Zero or more list elements.
             |          |      |
             | A single list element
                        |      |
                        | A condition for the pattern
                               |
                               | What to replace the pattern with

Python 3, 72 bytes

from random import*
while m!=sorted(m):p=randrange(8);m[p:p]=m.pop(p+1),

El bogosort (también conocido como clasificación estúpida): intercambia elementos vecinos al azar hasta que se ordene la matriz. Por lo general, corre menos de un segundo.

2 bytes gracias a @xnor.

Pitón 2, 45

for i in range(8)*8:m[i:i+2]=sorted(m[i:i+2])

Ciclos alrededor de la lista, ordenando pares consecutivos de elementos. El índice se idesplaza 0,1,2,3,4,5,6,7ocho veces, lo que garantiza que todos los elementos salgan y la lista se ordena.

Pyth, 13-15 bytes

Solución que realiza el intercambio solicitado y no produce resultados:

#X=Qhf>FT.:Q2

Solución que realiza el intercambio solicitado e imprime el estado intermedio de la lista en cada paso:

#QX=Qhf>FT.:Q2

Solución que realiza el intercambio solicitado e imprime el estado final de la lista:

#X=Qhf>FT.:Q2;Q

Demostración de la solución intermedia anterior.

El método de intercambio de valores adyacentes se toma de la respuesta de @ Jakube.

El programa usa #, el ciclo hasta la declaración de error, para intercambiar un par adyacente de elementos desordenados hasta que no exista dicho par, en cuyo punto h, la función de cabecera, arroja un error, finalizando el programa.

Retina , 95 93 bytes

No es particularmente competitivo (y probablemente todavía golfable), pero aquí vamos ...

(.)1
1$1
([^1])2
2$1
([4-9])3
3$1
([5-9])4
4$1
([6-9])5
5$1
([7-9])6
6$1
(8|9)7
7$1
)`98
89
<empty>
<empty>

Donde <empty>debería haber una línea vacía.

Como todos los números son de un solo dígito, esto solo espera una cadena con los 9 dígitos como entrada y se imprimirá 123456789después de ordenarla correctamente. Cada etapa realiza un intercambio único y el)1` indica que todas menos la última etapa deben repetirse hasta que el resultado deje de cambiar.

La etapa vacía al final es necesaria, porque de lo contrario obtendríamos resultados intermedios cada vez que 98se procese la etapa.

Aquí están todos los resultados intermedios (cada vez que cambia) para un ejemplo de ejecución:

451629387
451269387
451263987
451263978
415263978
412563978
412536978
412536798
412536789
142536789
124536789
124356789
123456789

(Obtuve esto agregando la :opción a cada etapa y eliminé los duplicados consecutivos manualmente).

Pyth, 17 bytes

uXGhaf>FT.:G2]Z)Q

Cambiar elementos en una lista es realmente costoso en Pyth. Así que aquí hay una solución divertida, que estira un poco las reglas. Probablemente no sea válido.

Pruébelo en línea: Pyth Compiler / Executor

Explicación

En primer lugar, la complejidad temporal de mi código es O(n^3). Pero esta no es la parte interesante. La pregunta no dice nada sobre la complejidad.

La parte crítica es cómo cambio dos elementos en la lista. Digamos que quiero cambiar los elementos m[3]y m[4]. No me importan los índices 3y 4en absoluto. Simplemente creo una segunda lista, que reemplaza cada elemento igual m[3]con el número m[4]y cada número igual m[4]con el valor m[3]. Como la lista no contiene duplicados, esto simula cambiar estos dos valores. Si hubiera duplicados, como en la entrada [1, 3, 2, 2], la salida sería [1, 2, 3, 3]. Y si das la entrada [1, 2, 1], terminaría en un bucle infinito. No creo explícitamente la segunda lista, es solo parte de la implementación de Pyth del método de traducción. Si imprime las listas actuales ( consulte aquí), proporciona los valores correctos, que usted esperaría.

                   implicit: Q = input list
u               Q  set G = Q, update G as long with the following statements, 
                   until it stops changing: 
         .:G2         all pairs (G[i],G[i+1])
     f>FT             filter for pairs T, where T[0] > T[1]
    a        ]Z       add to this list of pairs [0] 
                      (ensures that the filtered list is always non-empty)
   h                  take the first element
 XG            )      translate G by this pair (switches the values T[0] with T[1])
                   print implicitly at the end 

JavaScript (ES6) 56

Una función recursiva que reorganiza la lista dada en su lugar.

F=l=>l.some((v,i)=>v>l[++i]&&[l[i-1]=l[i],l[i]=v])&&F(l)

Notas

• En JS, para cualquier valor numérico v: v> undefined == false, v <undefined == false. Entonces, salir de los límites de la matriz no es un problema si utilizamos la comparación correcta

• Cuando finalmente se ordena la matriz, la función dentro de 'some' devuelve false y la recursión termina

• El valor devuelto en el caso de un intercambio es una matriz de 2 elementos, y su valor siempre es 'verdadero'. Eso funciona incluso cuando uno o más elementos de la matriz son 0

• De hecho, la función funciona con cualquier entrada numérica, no solo dígitos únicos y no repetidos. No encontré una manera de aprovechar esta restricción de OP.

Prueba con un fragmento (en Firefox): la versión del fragmento muestra los valores de la lista actual en cada paso.

F=l=>(log('L='+l), l.some((v,i)=>v>l[++i]&&[l[i-1]=l[i],l[i]=v])&&F(l))

function log(x) {
   L.innerHTML = L.innerHTML +x+'\n' 
}

function go() {
  l = I.value.split(/\D+/g).map(x=>x|0)
  F(l)
  O.innerHTML = '' + l
}  

go()

Unsorted: <input id=I value="2 8 4 7 5 3 9 1 6"><button onclick="go()">-></button>
<br>Sorted: <span id=O></span>
<br>Operations log:<br>
<pre id=L></pre>

Javascript ( ES6 ), 66 61 53 bytes

Gracias a la nueva regla, puedo reducir aún más :)

f=x=>x.map((a,i)=>a<(b=x[--i])&&f(x,x[i]=a,x[i+1]=b))


// Snippet demo: (Firefox only)
f(z=prompt().split(/\D+/).map(x=>+x))
alert(z.join(', '));

Comentado

f=x=> // recursive function f
    x.map( // map function to array
        (a, i)=> // a = current value, i = current index
            a < (b = x[--i]) && // poll value of previous index, compare less than
                                // comparison always false at first index as undefined will always be less
                f(x, x[i] = a, x[i + 1] = b) // if true, swap values and call f
    )

C, 183

main(c,d,s){int a[10];for(c=0;c<10;c++)scanf("%d", &a[c]);for (c=0;c<10;c++){for(d=0;d<10-c-1;d++){if(a[d]>a[d+1]){s=a[d];a[d]=a[d+1];a[d+1]=s;}}}for(c=0;c<10;c++)printf("%d", a[c]);}

Todavía no se juega golf, aparte de los nombres de variables.

Haskell, 59 bytes

s e(h:t)=min e h:max e h:t
f l=iterate(init.foldr s[9])l!!9

La función scoloca un elemento eal frente o en el segundo lugar de una lista dependiendo de si es menor o mayor que el primer elemento de la lista. Al plegarse sen la lista de entrada, el elemento más pequeño aparece al frente. Me estoy plegando en una lista que contiene una sola 9que elimino inmediatamente después init, para que no tenga que buscar listas vacías s. iteraterepite el proceso de plegado para siempre creando una lista de resultados intermedios. El resultado final es el noveno elemento de esta lista.

Perl, 68 bytes

{for(0..7){if($m[$_]>$m[$_+1]){splice@m,$_,2,$m[$_+1],$m[$_];redo}}}

Código sin golf

 {                                             # Block runs once unless redo is called

     for (0..7) {                                 # Loop index is in $_

         if ($m[$_] > $m[$_+1]) {                 # Check if swap needed

             splice @m, $_, 2, $m[$_+1], $m[$_];  # Replace a two element slice of
                                                  # the array with those 
                                                  # two elements reversed

             redo                                 # Restart the block over
         }
     }
}