O desafio

Na verdade, é bastante simples, classifique uma lista de números.

Detalhes

Você deve classificar uma lista de números em ordem crescente, sem usar nenhuma função de classificação / bibliotecas / etc (por exemplo, list.sort()em Python).

A entrada / saída pode ser feita de qualquer método que você escolher, desde que seja legível por humanos.

As brechas padrão são proibidas como sempre.

O menor código em bytes vence.

Você deve explicar / listar o método de classificação que você usou (bolha, inserção, seleção etc.)

A entrada não conterá duplicatas.

Entrada / Saída de amostra

Entrada: 99,-2,53,4,67,55,23,43,88,-22,36,45

Saída: -22,-2,4,23,36,43,45,53,55,67,88,99

Nota: Um oposto quase direto de Classificar uma lista de números

05AB1E , 2 bytes

Código:

ϧ

Mesmo algoritmo que a resposta Jelly . Calcula todas as permutações da entrada e sai a menor.

Experimente online!

Um método mais eficiente é:

E[ß,Ž

Executa a classificação de seleção . Usa a codificação CP-1252 .

Experimente online!

Geléia, 3 bytes

Œ!Ṃ

Isso gera todas as permutações da lista de entrada e, em seguida, seleciona a menor permutação lexograficamente. Muito eficiente.

Créditos para @Adnan que tiveram a mesma ideia de forma independente.

Experimente online!

Gelatina, 4 bytes

ṂrṀf

Isso cria o intervalo do mínimo da lista ao máximo da lista e descarta os elementos do intervalo que não estão presentes na lista original. Tecnicamente, esse é um tipo de caçamba , com caçambas muito pequenas. Não estou ciente de um nome para esta variante específica.

Experimente online!

Como funciona

ṂrṀf  Main link. Argument: A (list/comma-separated string)

Ṃ     Compute the minimum of A.
  Ṁ   Compute the maximum of A.
 r    Yield the inclusive range from the minimum to the maximum.
   f  Filter the range by presence in A.

Python, 46 45 bytes

lambda l:[l.pop(l.index(min(l)))for _ in 1*l]

Classificação de seleção simples.

Braquilog , 12 7 bytes

p.'(s>)

Isso usa o tipo de permutação, o que é obviamente terrível, mas ei, é mais curto que o Pyth!

Explicação

p.       Unifies the output with a permutation of the input
  '(  )  True if what's inside the parentheses cannot be proven, else backtrack and
         try with another permutation of the input.
    s    Take an ordered subset from the output
     >   True if the first element is bigger than the second (hence not sorted)
         We don't need to check that the subset is 2 elements long because > will be false
         for inputs that are not 2 elements long anyway

Haskell, 38 bytes

h%t|(a,b)<-span(<h)t=a++h:b
foldr(%)[]

A função binária %insere um novo elemento hem uma lista classificada t, particionando tem um prefixo ade elementos <he um sufixo bde elementos >he fica hentre eles.

A operação foldr(%)[]então cria uma lista classificada de vazia, inserindo repetidamente elementos da lista de entrada.

Esse é um byte menor que a implementação recursiva direta

f(h:t)|(a,b)<-span(<h)$f t=a++h:b
f x=x

Outra estratégia para 41 bytes:

f[]=[]
f l|x<-minimum l=x:f(filter(/=x)l)

JavaScript (ES6), 51 bytes

a=>a.map(_=>m=Math.min(...a.filter(e=>e>m)),m=-1/0)

Cada loop encontra o menor número que não foi encontrado até o momento.

Python 2, 34 bytes

def f(s):m=min(s);print m;f(s-{m})

Recebe a entrada como um conjunto, imprimindo seus elementos em ordem crescente, terminando com erro.

Uma terminação limpa pode ser feita em 41 bytes:

def f(s):
 if s:m=min(s);print m;f(s-{m})

ou

l=input()
while l:m=min(l);print m;l-={m}

A entrada pode ser tomada como uma lista de 39 bytes ou 38 bytes no Python 3.5:

def f(l):m=min(l);print m;f(set(l)-{m})
def f(l):m=min(l);print(m);f({*l}-{m})

Haskell, 42 41 38 bytes

f u=filter(`elem`u)[(minBound::Int)..]

Percorre todos os inteiros (assinado de 64 bits, na minha máquina) e mantém aqueles que estão em u. Claro que não termina em tempo razoável.

A versão anterior repetiu com [minimum u..maximum u]o mesmo pior caso de tempo de execução.

Edit: @xnor salvou um byte. Obrigado!

Oracle SQL 11.2, 205 bytes

WITH s AS(SELECT COLUMN_VALUE||''e FROM XMLTABLE(('"'||REPLACE(:1,',','","')||'"'))),v(p,f)AS(SELECT e,e FROM s UNION ALL SELECT p||','||e,e FROM v,s WHERE e+0>f)SELECT p FROM v WHERE LENGTH(p)=LENGTH(:1);         

Sem golfe

WITH 
s AS  -- Split the string using ',' as separator
(     -- ||'' cast the xml type to varchar
  SELECT COLUMN_VALUE||''e FROM XMLTABLE(('"'||REPLACE(:1,',','","')||'"'))
),  
v(p,f) AS  -- Recursive view : p = sorted string, f last number added
(
  SELECT e,e FROM s -- use each number as seed
  UNION ALL         -- only add a number if it is > the last added
  SELECT p||','||e,e FROM v,s WHERE e+0>f  -- +0 is needed to compare int and not strings
)  
-- The valid string has the same length as the input
SELECT p FROM v WHERE LENGTH(p)=LENGTH(:1)          

Quanto ao método de classificação, não faço ideia, ORDER BYme esqueci.

código de máquina x86-16 (BubbleSort int8_t), 20 19 bytes

código de máquina x86-64 / 32 (JumpDownSort) 21 19 bytes

Changelog:

• Agradeço a @ ped7g pela ideia lodsb/ cmp [si],ale a juntar isso com um incremento / redefinição de ponteiro que eu estava olhando. Não precisamos al/ ahvamos usar quase o mesmo código para números inteiros maiores.

• Novo algoritmo (mas relacionado), muitas alterações na implementação: O Bubbly SelectionSort permite uma implementação menor do x86-64 para bytes ou dwords; ponto de equilíbrio em x86-16 (bytes ou palavras). Também evita o erro no tamanho = 1 que meu BubbleSort possui. Ver abaixo.

• Acontece que meu Bubbly Selection Sort com swaps toda vez que você encontra um novo min já é um algoritmo conhecido, JumpDown Sort. É mencionado em Bubble Sort: Uma Análise Algorítmica Arqueológica (ou seja, como o Bubble Sort se tornou popular apesar da sucção).

Classifica inteiros assinados de 8 bits no local . (Não assinado é do mesmo tamanho de código, basta alterar jgepara a jae). Duplicatas não são um problema. Trocamos usando uma rotação de 16 bits por 8 (com um destino de memória).

O Bubble Sort é péssimo para desempenho , mas eu li que é um dos menores implementados em código de máquina. Isso parece especialmente verdadeiro quando há truques especiais para trocar elementos adjacentes. Essa é praticamente sua única vantagem, mas às vezes (em sistemas embarcados na vida real) é vantagem suficiente para usá-lo em listas muito curtas.

Omiti a rescisão antecipada sem trocas . Eu usei o loop BubbleSort "otimizado" da Wikipedia, que evita olhar os últimos n − 1itens durante a execução pela nquinta vez, de modo que o contador de loop externo é o limite superior do loop interno.

Listagem NASM ( nasm -l /dev/stdout) ou fonte simples

 2 address  16-bit       bubblesort16_v2:
 3          machine      ;; inputs: pointer in ds:si,  size in in cx
 4          code         ;; requires: DF=0  (cld)
 5          bytes        ;; clobbers: al, cx=0
 6                       
 7 00000000 49               dec     cx          ; cx = max valid index.  (Inner loop stops 1 before cx, because it loads i and i+1).
 8                       .outer:                 ; do{
 9 00000001 51               push    cx          ;   cx = inner loop counter = i=max_unsorted_idx
10                       .inner:                 ;   do{
11 00000002 AC               lodsb               ;     al = *p++
12 00000003 3804             cmp     [si],al     ;     compare with *p (new one)
13 00000005 7D04             jge     .noswap
14 00000007 C144FF08         rol     word [si-1], 8    ; swap
15                       .noswap:
16 0000000B E2F5             loop    .inner      ;   } while(i < size);
17 0000000D 59               pop     cx          ;  cx = outer loop counter
18 0000000E 29CE             sub     si,cx       ;  reset pointer to start of array
19 00000010 E2EF             loop    .outer      ; } while(--size);
20 00000012 C3               ret

22 00000013  size = 0x13 = 19 bytes.

push / pop cxao redor do loop interno significa que ele roda com cx= outer_cx até 0.

Observe que rol r/m16, imm8não é uma instrução 8086, foi adicionada posteriormente (186 ou 286), mas isso não está tentando ser o código 8086, apenas x86 de 16 bits. Se o SSE4.1 phminposuwajudasse, eu o usaria.

Uma versão de 32 bits disso (ainda operando em números inteiros de 8 bits, mas com ponteiros / contadores de 32 bits) tem 20 bytes (prefixo do tamanho do operando ativado rol word [esi-1], 8)

Bug: size = 1 é tratado como size = 65536, porque nada nos impede de entrar no fazer externo / enquanto com cx = 0. (Você normalmente usaria jcxzpara isso.) Mas, felizmente, a Classificação JumpDown de 19 bytes tem 19 bytes e não tem esse problema.

Versão original de 20 bytes x86-16 (sem a idéia de Ped7g). Omitido para economizar espaço, consulte o histórico de edições com uma descrição.

atuação

O armazenamento / recarregamento parcialmente sobreposto (na rotação do destino da memória) causa uma interrupção do encaminhamento de loja nas CPUs x86 modernas (exceto Atom em ordem). Quando um valor alto está subindo, essa latência extra faz parte de uma cadeia de dependência transportada por loop. Armazenar / recarregar é uma porcaria em primeiro lugar (como latência de encaminhamento de loja de 5 ciclos em Haswell), mas uma paralisação de encaminhamento leva a mais de 13 ciclos. A execução fora de ordem terá problemas para ocultar isso.

Consulte também: Estouro de pilha: classificação de bolha para classificar sequência de caracteres para uma versão disso com uma implementação semelhante, mas com uma saída antecipada quando não são necessários swaps. Ele usa xchg al, ah/ mov [si], axpara troca, que é 1 byte mais longo e causa uma parada parcial do registro em algumas CPUs. (Mas ainda pode ser melhor que a rotação da memória-dst, que precisa carregar o valor novamente). Meu comentário tem algumas sugestões ...

Classificação JumpDown x86-64 / x86-32, 19 bytes (classifica int32_t)

É possível chamar de C usando a convenção de chamada do System V x86-64 como
int bubblyselectionsort_int32(int dummy, int *array, int dummy, unsigned long size); (valor de retorno = max (matriz [])).

Isso é https://en.wikipedia.org/wiki/Selection_sort , mas em vez de lembrar a posição do elemento min, troque o candidato atual na matriz . Depois de encontrar o mínimo (região não classificada), armazene-o no final da região classificada, como Classificação normal da seleção. Isso aumenta a região classificada em um. (No código, rsiaponta para um além do final da região classificada; lodsdavança e mov [rsi-4], eaxarmazena o min novamente nela.)

O nome Jump Down Sort é usado em Bubble Sort: An Aritological Algorithmic Analysis . Acho que minha classificação é realmente uma classificação Jump Up, porque os elementos altos saltam para cima, deixando a parte inferior classificada, não o fim.

Esse design de troca faz com que a parte não classificada da matriz acabe na ordem mais inversa, levando a muitos swaps posteriormente. (Como você começa com um candidato grande e continua vendo candidatos cada vez mais baixos, continua trocando). Eu o chamei de "borbulhante", mesmo que ele mova os elementos na outra direção. A maneira como ele move os elementos também é um pouco como um tipo de inserção para trás. Para assisti-lo em ação, use GDBs display (int[12])buf, defina um ponto de interrupção na loopinstrução interna e use c(continuar). Pressione retornar para repetir. (O comando "display" faz com que o GDB imprima todo o estado da matriz toda vez que atingimos o ponto de interrupção).

xchgcom mem tem um lockprefixo implícito que torna isso mais lento. Provavelmente uma ordem de magnitude mais lenta que uma troca eficiente de carga / loja; xchg m,ré um por taxa de transferência de 23c no Skylake, mas carregar / armazenar / mover com um registro tmp para uma troca eficiente (reg, mem) pode mudar um elemento por relógio. Pode ser uma proporção pior em uma CPU AMD em que a loopinstrução é rápida e não prejudica tanto o loop interno, mas as falhas de ramificação ainda serão um grande gargalo porque os swaps são comuns (e se tornam mais comuns à medida que a região não classificada fica menor) )

 2 Address               ;; hybrib Bubble Selection sort
 3        machine         bubblyselectionsort_int32:   ;; working, 19 bytes.  Same size for int32 or int8
 4        code               ;; input: pointer in rsi, count in rcx
 5        bytes              ;; returns: eax = max
 6                       
 7                           ;dec  ecx           ; we avoid this by doing edi=esi *before* lodsb, so we do redundant compares
 8                                               ; This lets us (re)enter the inner loop even for 1 element remaining.
 9                       .outer:
10                           ; rsi pointing at the element that will receive min([rsi]..[rsi+rcx])
11 00000000 56               push   rsi
12 00000001 5F               pop    rdi
13                           ;mov    edi, esi     ; rdi = min-search pointer
14 00000002 AD               lodsd
16 00000003 51               push   rcx          ; rcx = inner counter
17                       .inner:                   ; do {
18                           ; rdi points at next element to check
19                           ; eax = candidate min
20 00000004 AF               scasd                 ; cmp eax, [rdi++]
21 00000005 7E03             jle  .notmin
22 00000007 8747FC           xchg   [rdi-4], eax   ; exchange with new min.
23                         .notmin:
24 0000000A E2F8             loop  .inner          ; } while(--inner);
26                           ; swap min-position with sorted position
27                           ; eax = min.  If it's not [rsi-4], then [rsi-4] was exchanged into the array somewhere
28 0000000C 8946FC           mov    [rsi-4], eax
29 0000000F 59               pop   rcx           ; rcx = outer loop counter = unsorted elements left
30 00000010 E2EE             loop  .outer        ; } while(--unsorted);
32 00000012 C3               ret

34 00000013 13           .size: db $ - bubblyselectionsort_int32
           0x13 = 19 bytes long

O tamanho do código mesmo para int8_t: uso lodsb/ scasb, ALe alterar o [rsi/rdi-4]que -1. O mesmo código de máquina funciona no modo de 32 bits para elementos de 8/32 bits. O modo de 16 bits para elementos de 8/16 bits precisa ser reconstruído com as compensações alteradas (e os modos de endereçamento de 16 bits usam uma codificação diferente). Mas ainda 19 bytes para todos.

Evita a inicial dec ecxcomparando com o elemento que acabou de carregar antes de prosseguir. Na última iteração do loop externo, ele carrega o último elemento, verifica se é menor que ele próprio e, em seguida, está pronto. Isso permite que ele funcione com tamanho = 1, onde meu BubbleSort falha (trata-o como tamanho = 65536).

Testei esta versão (no GDB) usando o chamador deste: Experimente online! . Você pode executá-lo no TIO, mas é claro que não há depurador nem impressão. Ainda assim, o _startque o chama sai com exit-status = maior elemento = 99, para que você possa ver que funciona.

C, 72 bytes

i,j;a(int*l,int n){for(i=0;i=i?:--n;j>l[n]?l[i]=l[n],l[n]=j:0)j=l[--i];}

Tipo de bolha. O primeiro argumento é um ponteiro para a matriz, o segundo argumento é o comprimento da matriz. Funciona com o gcc.

MATL , 11 10 bytes

Y@t!d0>AY)

Exame extremamente ineficiente de todas as permutações da entrada.

Experimente Online!

Explicação

        % Implicitly grab input array
Y@      % Compute all permutations (each permutation as a row)
t       % Duplicate this matrix
!d      % Transpose and take the differences between the values
0>A     % Find the rows where all differences are > 0
Y)      % Return only the row where this is true
        % Implicitly display the result

Ruby, 40 bytes

Classificação de seleção. Função anônima; toma a lista como argumento.

->a{r=[];r<<a.delete(a.min)while[]!=a;r}

Python, 120 bytes

def f(a):import time,threading;[threading.Thread(None,lambda b=b,c=min(a):print(time.sleep(b-c)or b)).start()for b in a]

Provavelmente, essa não será a resposta mais curta, mas acho que esse algoritmo pertence aqui. Se você ligar com uma lista de números inteiros, eles serão impressos de maneira classificada para stdout. Eu não tentaria isso com números muito grandes.

MIPS, 68 bytes

Eu escrevi uma implementação simples e não otimizada de classificação de bolhas há um tempo atrás. A contagem de bytes começa às loope termina às li $v0, 10, assumindo que o endereço e o comprimento da lista já estejam na memória.

 Address    Code        Basic                     Source

0x00400000  0x3c011001  lui $1,4097           5    main:   la      $s0, list       # List address
0x00400004  0x34300000  ori $16,$1,0               
0x00400008  0x2411000a  addiu $17,$0,10       6            li      $s1, 10         # List length
0x0040000c  0x24080000  addiu $8,$0,0         8    loop:   li      $t0, 0          # swapped
0x00400010  0x24090001  addiu $9,$0,1         9            li      $t1, 1          # for loop "i"
0x00400014  0x1131000b  beq $9,$17,11         11   for:    beq     $t1, $s1, fend  # break if i==length
0x00400018  0x00095080  sll $10,$9,2          13           sll     $t2, $t1, 2     # Temp index, multiply by 4
0x0040001c  0x01505020  add $10,$10,$16       14           add     $t2, $t2, $s0   # Combined address
0x00400020  0x8d4b0000  lw $11,0($10)         15           lw      $t3, 0($t2)     # list[i]
0x00400024  0x8d4cfffc  lw $12,-4($10)        16           lw      $t4, -4($t2)    # list[i-1]
0x00400028  0x21290001  addi $9,$9,1          18           addi    $t1, $t1, 1     # i++
0x0040002c  0x016c082a  slt $1,$11,$12        20           ble     $t4, $t3, for   # if list[i-1] > list[i]
0x00400030  0x1020fff8  beq $1,$0,-8               
0x00400034  0xad4bfffc  sw $11,-4($10)        21           sw      $t3, -4($t2)    # swap and store
0x00400038  0xad4c0000  sw $12,0($10)         22           sw      $t4, 0($t2)     
0x0040003c  0x24080001  addiu $8,$0,1         23           li      $t0, 1          # swapped=true
0x00400040  0x08100005  j 0x00400014          24           j       for
0x00400044  0x20010001  addi $1,$0,1          26   fend:   subi    $s1, $s1, 1     # length--
0x00400048  0x02218822  sub $17,$17,$1             
0x0040004c  0x1500ffef  bne $8,$0,-17         27           bnez    $t0, loop       # Repeat if swapped==true
0x00400050  0x2402000a  addiu $2,$0,10        29           li      $v0, 10        
0x00400054  0x0000000c  syscall               30           syscall

Agora espero ser expulso da água com x86 ...

Awk, 66 bytes

{b=$0;a[b]}m<b{m=b}n>b{n=b}END{for(i=n;i<=m;i++)if(i in a)print i}

Matrizes no awk são como dicionários, não como matrizes C. Os índices podem ser não contíguos e aumentam (e são criados) conforme necessário. Então, criamos uma matriz apara a entrada, com cada linha sendo uma chave. E salvamos os valores mínimo e máximo. Em seguida, fazemos um loop de min a max e imprimimos todas as chaves existentes a. bé apenas para evitar o uso repetido de $0.

Python 3, 91 62 47 bytes

def f(z):
 while z:m=min(z);z.remove(m);yield m

Agradecimentos a wnnmaw e Seeq pela ajuda no golfe.

O argumento zdeve ser uma lista. Essa é uma variante da classificação de seleção.

Não sei ao certo como se mincompara built-in sorting functions, pois não tenho certeza de como o Python implementa min. Felizmente, esta solução ainda está bem. Quaisquer sugestões de golfe nos comentários ou no chat PPCG são bem-vindas.

MATL , 11 bytes

`t4#X<2#)tn

Experimente online!

Isso é ordenado pelo seguinte procedimento, que é O ( n ² ):

1. Pegue o mínimo da matriz.
2. Remova esse valor da matriz e armazene-o para exibição subsequente.
3. Aplique o mesmo procedimento com o restante da matriz, até que fique vazio.
4. Exiba todos os números na ordem em que foram obtidos.

MATL é baseado em pilha. A matriz com os valores restantes é mantida no topo da pilha. Os valores removidos estão abaixo, em ordem. No final do programa, todos esses valores são exibidos. A matriz na parte superior também seria exibida, mas, como está vazia, não é exibida.

`        % Do...while loop
  t      %   Duplicate. Implicitly take input in the first iteration
  4#X<   %   Compute index of mininum of the array
  2#)    %   Push the minimum, and then the array with remaining entries
  tn     %   Duplicate and push number of elements, to be used as loop condition
         % Implicitly end do...while loop
         % Implicitly display stack contents

Pitão - 15 13 11 10 bytes

Dois bytes salvos graças ao @Jakube.

Bogosort.

f!s>VTtT.p

Experimente online aqui .

Eu não preciso do hporque estamos garantidos sem duplicatas.

Sério, 6 bytes

,;l@╨m

Experimente online!

Isso faz o mesmo que muitas outras respostas: gere todas as permutações, selecione o mínimo. Eu meio que esqueci que isso funcionaria enquanto eu estava trabalhando na solução abaixo.

Explicação:

,;l@╨m
,;l@    push len(input), input
    ╨m  minimum permutation

Sério, 25 bytes (não concorrente)

Isso seria competitivo se não fosse por um erro no comando shuffle que eu consertei.

,1WX╚;;pX@dXZ`i@-0<`MπYWX

Experimente online! Isso implementa o melhor algoritmo de classificação de todos os tempos: Bogosort !

Explicação:

,1WX╚;;pX@dXZ`i@-0<`MπYWX
,                          get input
 1W                    WX  do-while:
   X                         discard
    ╚                        shuffle
     ;;                      dupe twice
       pX@dX                 remove first element of first dupe and last element of second dupe
            Z                zip
             `i@-0<`MπY      test if all differences are positive (if any are not, the list is not sorted), negate (1 if not sorted else 0)

MATL, 17 16 bytes

Salvo um byte, criando um array nulo graças a @LuisMendo

vTbtX<-QI$(f8M+q

Classificação de balde. Não tente com um intervalo maior que 2 ³¹ -1.

Experimente online!

Explicação

v                  % push an empty array
 T                 % push 1
  b                % bubble the input array up to the top of the stack
   t               % duplicate it
    X<             % find the minimum
      -            % subtract min from input array
       Q           % and increment to adjust for 1-based indexing
        I$(        % resulting array used as indices of empty array 
                   % (the [] way up at the top) that are assigned 1 (from T)
           f       % find the nonzero indices
            8M     % magically retrieve the 4th previous function input :/
                     (aka, the min input array value)
              +    % add it to the indices
               q   % and decrement

TIL:

• Você pode inicializar uma matriz vazia no MATL usando []e aumentá-la, assim como no MATLAB
• Como usar (para indexação de atribuição
• Como usar a Márea de transferência automática

Novo dia, novo TIL:

• vertcat magicamente cria uma matriz vazia quando não há nada na pilha para concatenar

Julia, 28 27 bytes

x->colon(extrema(x)...)∩x

Experimente online!

R, 68 bytes

Toma entradas ie saídas, oque é a lista classificada.

o<-i
for(j in 1:length(i)){
x<-(i-min(i))==0
o[j]<-i[x]
i<-i[!x]
}
o

Explicação:

o<-i                      # Defines output as o
 for(j in 1:length(i)){   # Initializes loop for length of input
  x<-(i-min(i))==0        # Generates logical vector by finding the value 0 
                          # of input less the minimum of input. 
   o[j]<-i[x]             # Puts the smallest value at position j
    i<-i[!x]              # Removes the smallest value from input
      }                   # Ends loop
       o                  # Returns sorted list

Evitar as permutações significa que pode classificar grandes listas com relativa rapidez. O "truque" é que subtrair o menor valor da entrada deixa um único 0 que determina o menor valor e a posição do menor valor.

Java 8, 112 92 bytes

Aqui está outro tipo de seleção. A entrada é um número List tinteiro e a saída classificada é impressa na saída padrão.

t->{for(;0<t.size();System.out.println(t.remove(t.indexOf(java.util.Collections.min(t)))));}

Atualizar

• -20 [16-08-21] Usou um lambda

Retina, 95

Classificação de bolha modificada. Eu suspeito que existem maneiras muito melhores de fazer isso, mesmo sem o tipo de retina embutido.

-\d+
$*n
\d+
$*11
+`(1+) (n+)
$2 $1
+`\b(n+) (\1n+)|(1+)(1+) \3\b
$2$3 $1$3$4
1(1*)
$.1
n+
-$.&

• Etapa 1 - converta -ve números inteiros em unários com n o dígito; largar os -sinais.
• Estágio 2 - converta + ve e zero inteiros em unário com 1o dígito; adicionar1 a cada um, para que zero seja representado por1 .
• Etapa 3 - Mova todas as vezes para a frente.
• Etapa 4 - Classificação: mova todos os -ves com a maior magnitude (ou seja, o menor numérico) à frente dos -ves superiores. Mova + ves menores à frente de + ves maiores.
• Etapa 5 - remova 1 de e converta + ve unários de volta para decimal.
• Estágio 6 - converta -vários de volta para decimal, incluindo sinal.

Experimente online.

Ruby, 22 bytes

Um tipo de permutação rápida . Executa no O (n!) Espaço e tempo.

->a{a.permutation.min}

Clojure, 73 35 bytes

Bogosort :)

#(if(apply < %)%(recur(shuffle %)))

Versão anterior:

#(reduce(fn[r i](let[[a b](split-with(partial > i)r)](concat a[i]b)))[]%)

Reduz para uma lista classificada r, dividindo-a em partes "menores que eu" e "maiores que eu". Eu acho que esse é o tipo de inserção .

Ruby, 26 24 bytes

Tipo de seleção, semelhante à resposta da Value Ink, mas usando uma abordagem diferente para aumentar a golfabilidade.

De acordo com a especificação: "A entrada / saída pode ser feita em qualquer método que você escolher, desde que seja legível por humanos". Eu acho que isso se encaixa na descrição, a saída é uma matriz de matrizes com um único elemento.

->l{l.map{l-l-=[l.min]}}

exemplo:

->l{l.map{l-l-=[l.min]}}[[2,4,3,1]]
=> [[1], [2], [3], [4]]

Java 7, 106 104 bytes

void a(int[]a){for(int b=a.length-1,d=0,c=0,e;d<b*b;c=++d%b)if(a[c]>a[c+1]){e=a[c];a[c++]=a[c];a[c]=e;}}

Aqui está um bom tipo de bolha oleosa. O parâmetro de função é modificado no local para que eu não precise retornar nada. Ainda estou tentando espremer alguns bytes disso para que eu possa vencer o java lambda que alguém postou.

-1 byte graças a Geobits por apontar que a troca normal é melhor do que xor'ing
-1 byte graças a Leaky Nun por apontar que eu posso mover todas as declarações int para o loop for

Experimente online!

Ruby, 22 bytes

->a{[*a.min..a.max]&a}

Cria uma matriz fora do intervalo entre os elementos mínimo e máximo da matriz de entrada. Retorna a interseção entre as duas matrizes.