A questão

Dado um conjunto de 9 números, m[]que contém apenas os números 1 a 9 em uma ordem aleatória, sem dois números iguais, crie um programa em qualquer idioma que reorganize o número em ordem numérica (1, 2, 3, etc. etc.) alternando apenas dois números próximos um do outro (ou seja, 1, 3, 2 → 1, 2, 3).

Regras

• Você só pode modificar o aparelho trocando dois números que estão próximos um do outro
• Os números finais (1 a 9 em ordem) devem estar contidos em m[]
• Você pode usar qualquer idioma que desejar
• A resposta com a menor quantidade de bytes ganha

Editar:

Seu código não não tem que imprimir a saída, mas a matriz rearranjada deve estar em m[].

CJam, 15 bytes

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

Como 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

Experimente online aqui

Mathematica, 38 bytes

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

Essa é uma função sem nome que utiliza uma matriz, que aplica uma regra de substituição até que o padrão não possa mais ser encontrado. O padrão é uma lista que possui dois elementos consecutivos be conde b > c, e a regra diz para trocar o be, de coutra forma, deixar a matriz intocada.

Há muito açúcar sintático aqui, mas o código é realmente muito legível se você conhece um pouco do 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),

A abordagem bogosort (também conhecida como classificação estúpida): troca elementos vizinhos aleatoriamente até que a matriz seja classificada. Geralmente é executado em menos de um segundo.

2 bytes graças a @xnor.

Python 2, 45

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

Percorre a lista, classificando pares consecutivos de elementos. O índice ipercorre 0,1,2,3,4,5,6,7oito vezes, o que garante que todos os elementos passem pela bolha e a lista é classificada.

Pitão, 13 - 15 bytes

Solução que executa a troca solicitada e não produz saída:

#X=Qhf>FT.:Q2

Solução que executa a troca solicitada e imprime o estado intermediário da lista a cada etapa:

#QX=Qhf>FT.:Q2

Solução que realiza a troca solicitada e imprime o estado final da lista:

#X=Qhf>FT.:Q2;Q

Demonstração da solução do meio acima.

O método de troca de valores adjacentes é retirado da resposta de @ Jakube.

O programa usa #, o loop até a instrução de erro, para trocar um par adjacente de elementos mal ordenados até que não exista esse par; nesse ponto h, a função head gera um erro, encerrando o programa.

Retina , 95 93 bytes

Não é particularmente competitivo (e provavelmente ainda jogável), mas aqui vamos nós ...

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

Onde <empty>deve haver uma linha vazia.

Como todos os números são de um dígito, isso espera apenas uma sequência com todos os 9 dígitos como entrada e será impressa 123456789após a classificação bem-sucedida. Cada estágio executa uma única troca e )1`indica que todos, exceto o último, devem ser repetidos até que o resultado pare de mudar.

O estágio vazio no final é necessário, porque, caso contrário, obteríamos resultados intermediários toda vez que o 98estágio for processado.

Aqui estão todos os resultados intermediários (sempre que isso muda) para um exemplo de execução:

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

(Eu obtive isso adicionando a :opção a cada estágio e me livrei de duplicatas consecutivas manualmente.)

Pitão, 17 bytes

uXGhaf>FT.:G2]Z)Q

Trocar itens de uma lista é realmente caro em Pyth. Então, aqui está uma solução divertida, que estende um pouco as regras. Provavelmente não é válido.

Experimente online: Pyth Compiler / Executor

Explicação

Primeiro de tudo, a complexidade do tempo do meu código é O(n^3). Mas essa não é a parte interessante. A pergunta não diz nada sobre a complexidade.

A parte crítica é como eu alterno dois elementos na lista. Digamos que eu queira mudar os elementos m[3]e m[4]. Eu não me importo com os índices 3e 4nada. Eu simplesmente crio uma segunda lista, que substitui todos os elementos iguais ao m[3]número m[4]e todos os números iguais ao m[4]valor m[3]. Como a lista não contém duplicatas, isso simula a troca desses dois valores. Se houvesse duplicatas, como na entrada [1, 3, 2, 2], a saída seria [1, 2, 3, 3]. E se você der a entrada [1, 2, 1], ela terminará em um loop infinito. Não crio explicitamente a segunda lista, é apenas parte da implementação do método de conversão por Pyth. Se você imprimir as listas atuais ( veja aqui), fornece os valores corretos que você esperaria.

                   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

Uma função recursiva que reorganiza a lista fornecida no local.

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

Notas

• Em JS, para qualquer valor numérico v: v> undefined == false, v <undefined == false. Portanto, sair dos limites da matriz não é um problema se usarmos a comparação correta

• Quando a matriz finalmente é classificada, a função dentro de 'some' retorna false e a recursão termina

• O valor retornado no caso de uma troca é uma matriz de 2 elementos e seu valor é sempre 'verdadeiro'. Isso funciona mesmo quando um ou mais elementos da matriz são 0

• De fato, a função funciona com qualquer entrada numérica, não apenas dígitos únicos e não repetidos. Não encontrou uma maneira de tirar proveito dessa restrição de OP.

Teste usando o snippet (no Firefox) - a versão do snippet gera os valores atuais da lista em cada etapa.

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

Graças à nova regra, posso reduzir ainda mais :)

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

Ainda não foi jogado, exceto por nomes de variáveis.

Haskell, 59 bytes

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

A função scoloca um elemento ena frente ou no segundo lugar de uma lista, dependendo se é menor ou maior que o primeiro elemento da lista. Dobrar sna lista de entrada permite que o menor elemento borbulhe para a frente. Estou entrando em uma lista contendo uma única 9que removo imediatamente depois init, para não precisar procurar listas vazias s. iteraterepete o processo de dobra para sempre, criando uma lista de resultados intermediários. O resultado final é o nono elemento desta lista.

Perl, 68 bytes

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

Código ungolfed

 {                                             # 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
         }
     }
}