Meydan okuma

Gerçekten çok basit, bir numara listesini sıralayın.

ayrıntılar

Herhangi bir yerleşik sıralama işlevi / kitaplıkları / etc kullanmadan (örneğin list.sort()Python'da) bir sayı listesini artan sırada sıralamanız gerekir .

Giriş / çıkış, insan tarafından okunabilir olduğu sürece seçtiğiniz herhangi bir yöntemde yapılabilir.

Standart boşluklar her zaman olduğu gibi izin verilmez.

Bayt cinsinden en kısa kod kazanır.

Hangi sıralama yöntemini kullandığınızı açıklamalı / listelemelisiniz (Kabarcık, Ekleme, Seçim vb.)

Giriş yinelenen içermez.

Örnek Giriş / Çıkış

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

Çıktı: -22,-2,4,23,36,43,45,53,55,67,88,99

Not: Sayı Listesini Sıralamanın hemen karşısına

05AB1E , 2 bayt

Kod:

ϧ

Jelly cevabı ile aynı algoritma . Girdideki tüm permütasyonları hesaplar ve en küçüğü çıkar.

Çevrimiçi deneyin!

Daha verimli bir yöntem:

E[ß,Ž

Seçim sırasını gerçekleştirir . CP-1252 kodlamasını kullanır .

Çevrimiçi deneyin!

Jöle, 3 bayt

Œ!Ṃ

Bu, giriş listesinin tüm permütasyonlarını oluşturur, ardından sözlüksel olarak en küçük permütasyonu seçer. Çok verimli.

Bağımsız olarak aynı fikri olan @Adnan'a kredi verir.

Çevrimiçi deneyin!

Jöle, 4 bayt

ṂrṀf

Bu, aralığı listenin minimum değerinden listenin maksimum değerine kadar oluşturur, ardından orijinal listede bulunmayan aralık öğelerini atar. Bu teknik olarak çok küçük kovalara sahip bir kova çeşididir. Bu özel değişken için bir isim bilmiyorum.

Çevrimiçi deneyin!

Nasıl çalışır

Ṃ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 bayt

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

Basit seçim sıralama.

Brachylog , 12 7 bayt

p.'(s>)

Bu, açıkça korkunç olan permütasyon türünü kullanıyor, fakat hey Pyth'den daha kısa!

açıklama

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 bayt

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

İkili fonksiyon %yeni bir eleman ekleme hSıralanmış listesine tayrıştırmak suretiyle tbir önek içine aelementlerin <hve bir sonek belemanlarının >hiçinde ve sopalarla haralarında.

İşlem foldr(%)[]daha sonra giriş listesindeki öğeleri tekrar tekrar ekleyerek boş bir sıralı liste oluşturur.

Bu doğrudan özyinelemeli uygulamadan bir bayt daha kısa

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

41 bayt için başka bir strateji:

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

JavaScript (ES6), 51 bayt

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

Her döngü, şu ana kadar bulunmayan en küçük sayıyı bulur.

Python 2,34 bayt

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

Girdiyi set olarak alır, öğelerini artan sırada yazdırır, hatayla sonlandırır.

41 baytta temiz bir sonlandırma yapılabilir:

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

veya

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

Giriş Python 3.5'te 39 bayt veya 38 baytlık bir liste olarak alınabilir:

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 bayt

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

Tüm tamsayılar arasında dolaşıyor (makinemde 64 bit imzalı) ve içinde olanları saklıyor u. Tabii ki makul bir zamanda bitmiyor.

Önceki sürüm [minimum u..maximum u]hangi en kötü durumda çalışma süresine sahip olan üzerinden geçti .

Düzenleme: @xnor bir bayt kaydetti. Teşekkürler!

Oracle SQL 11.2, 205 bayt

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

Un-golfed

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)          

Ne tür bir yöntem olduğu hakkında, hiçbir fikrim yok, ORDER BYonları unuttuğuma emin oldum.

x86-16 makine kodu (BubbleSort int8_t), 20 19 bayt

x86-64 / 32 makine kodu (JumpDownSort) 21 19 bayt

Değişiklikler:

• lodsb/ cmp [si],alFikri için @ ped7g'ye teşekkür ederim ve bunu, bakmakta olduğum bir işaretçi artırma / sıfırlama ile bir araya getirme . İhtiyaç duymamak al/ah daha büyük tamsayılar için neredeyse aynı kodu kullanmamıza izin verir.

• Yeni (ancak ilişkili) algoritma, birçok uygulama değişikliği: Bubbly SelectionSort, bayt veya şifre için daha küçük bir x86-64 uygulaması sağlar; x86-16'daki break-even (bayt veya sözcük). Ayrıca, BubbleSort'un sahip olduğu size = 1 büyüklüğündeki hatayı da engeller. Aşağıya bakınız.

• Bubbly Selection Sort'un, her yeni bir min bulduğunuzda swaplarla değiştirildiğini, JumpDown Sort'un zaten bilinen bir algoritma olduğu ortaya çıktı. Bubble Sort: Bir Arkeolojik Algoritmik Analiz'de bahsedilmiştir (örn. Bubble Sort emmeye rağmen nasıl popüler olmuştur).

Yerinde 8 bit işaretli tam sayıları sıralar . (İmzasız aynı kod boyutunda, sadece jgebirjae ). Kopyalar sorun değil. 16 bitlik bir döndürme kullanarak 8'e kadar (bellek hedefiyle) değiştiririz.

Bubble Sort performans için berbat , ancak bunun makine kodunda uygulanması en küçüklerinden biri olduğunu okudum. Bu, özellikle bitişik elemanları değiştirmek için özel numaralar olduğunda doğrudur. Bu hemen hemen tek avantajı, ancak bazen (gerçek yaşamdaki gömülü sistemlerde) bu onu çok kısa listelerde kullanmak için yeterli bir avantaj.

Erken feshi hiçbir takas üzerinde ihmal ettim . Wikipedia'nın "en iyi duruma getirilmiş" BubbleSort döngüsünü kullandım;n − 1n , bu süre -inci kez çalışırken öğelere , bu yüzden dış döngü sayacı iç döngü için üst sınırdır.

NASM listesi ( nasm -l /dev/stdout) veya düz kaynak

 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.

cxİç döngü etrafında itme / pop ile çalışır anlamına gelircx = 0'a kadar outer_cx .

Bunun rol r/m16, imm8bir 8086 talimatı olmadığını unutmayın, daha sonra eklendi (186 veya 286), ancak bu 8086 kodu, sadece 16 bit x86 olmaya çalışıyor. Eğer SSE4.1 isephminposuw yardım , kullanırdım.

Bunun 32 bit sürümü (hala 8 bit tam sayılarda çalışıyor, ancak 32 bit işaretçiler / sayıcılar ile çalışıyor) 20 bayttır (operand boyutu öneki açık rol word [esi-1], 8)

Hata: size = 1 size = 65536 olarak kabul edildi, çünkü hiçbir şey bizi dış do / girerken cx = 0 ile engellemiyor. (Normalde jcxzbunun için kullanırsınız.) Fakat neyse ki 19 bayt JumpDown Sıralaması 19 bayttır ve bu sorunu yaşamaz.

Orijinal x86-16 20 byte versiyonu (Ped7g'in fikri olmadan). Yer kazanmak için ihmal edildi, bir açıklama içeren düzenleme geçmişine bakın .

performans

Kısmen üst üste binen mağaza / yeniden yükleme (bellek hedefi döndürme modunda), modern x86 CPU'larda (sıralı Atom hariç) bir mağaza iletme duraklamasına neden olur. Yüksek bir değer yukarı doğru kabarcıklanırken, bu gecikme süresi döngü taşıma bağımlılık zincirinin bir parçasıdır. İlk etapta emmek saklayın / yeniden yükleyin (Haswell'deki 5 devirli mağaza ileri gecikme süresi gibi), ancak bir ileri alma kabini 13 tur gibi daha fazla sayı getirir. Sıra dışı yürütme bunu gizlemekte zorlanacaktır.

Ayrıca bakınız: Yığın Taşması: benzer bir uygulamayla, ancak herhangi bir takas gerekmediğinde erken bir zaman için bunun bir sürümü için dizgiyi sıralamak için kabarcık sıralaması . 1 bayt daha uzun olan ve bazı CPU'larda kısmi kayıt durmasına neden olan, takas için xchg al, ah/ kullanır mov [si], ax. (Ancak yine de değeri tekrar yüklemesi gereken bellek-dönme işleminden daha iyi olabilir). Benim yorumumun bazı önerileri var ...

x86-64 / x86-32 JumpDown Sıralama, 19 bayt (int32_t sıralar)

X86-64 System V arama kuralını kullanarak C'den çağrılabilir
int bubblyselectionsort_int32(int dummy, int *array, int dummy, unsigned long size); (dönüş değeri = maks (dizi [])).

Bu https://en.wikipedia.org/wiki/Selection_sort'tur , fakat min elemanının pozisyonunu hatırlamak yerine, mevcut adayı diziye değiştirirsiniz . Min'i (sıralanmamış_ bölge) bulduktan sonra, normal Seçim Sıralaması gibi, sıralanmış bölgenin sonuna kaydedin. Bu, sıralanan bölgeyi birer birer büyütür. (Kodda, rsisıralanan bölgenin sonundan bir tanesine işaret eder; lodsdonu ilerletir ve mov [rsi-4], eaxmin'i tekrar içine kaydeder.)

Jump Down Sort adı Bubble Sort: Bir Arkeolojik Algoritmik Analizde kullanılır . Sanırım benim sıralamam gerçekten bir Atlama Sıralaması, çünkü yüksek elemanlar yukarı doğru atlıyor, altını sıralı değil bırakarak.

Bu değişim tasarımı, dizinin sıralanmamış kısmına, çoğunlukla tersine sıralı bir şekilde, daha sonradan çok fazla takasla sonuçlanmasına neden olur. (Çünkü büyük bir adayla başlarsınız, daha düşük ve daha düşük adaylar görürsünüz, böylece değişmeye devam edersiniz.) Elemanları diğer yöne hareket etmesine rağmen “kabarcıklı” olarak adlandırdım. Elemanları hareket ettirme şekli de geriye doğru yerleştirme sıralaması gibidir. Hareket halindeyken izlemek için, GDB'leri kullanın display (int[12])buf, iç looptalimatlarda bir kesme noktası ayarlayın ve kullanın c(devam). Tekrarlamak için return tuşuna basın. ("Display" komutu, kesme noktasına her bastığımızda tüm dizi durumunu yazdırması için GDB'yi alır).

xchgmem ile lockbu ekstra yavaşlık yaratan bir önek vardır. Muhtemelen verimli bir yük / depo takasından daha yavaş bir büyüklük sırası; xchg m,rSkylake üzerindeki her 23c verimden bir tanesidir, ancak etkin bir değişim (reg, mem) için bir tmp reg ile yükle / kaydet / mov, saat başına bir elementi değiştirebilir. loopTalimatın hızlı olduğu ve iç döngüyü çok fazla sıkıntıya sokmayacağı bir AMD işlemcide daha kötü bir oran olabilir , ancak dallanmalar büyük bir darboğaz olacaktır, çünkü takaslar yaygındır (ve sıralanmamış bölge küçüldükçe daha yaygın hale gelir. ).

 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

İçin aynı kod boyutu int8_t: kullanım lodsb/ scasb, ALve değiştirmek [rsi/rdi-4]için-1 . Aynı makine kodu, 8/32-bit öğeler için 32-bit modunda çalışır. 8/16 bitlik elemanlar için 16 bitlik modun, ofsetlerin değiştirilmesiyle yeniden oluşturulması gerekir (ve 16 bitlik adresleme modları farklı bir kodlama kullanır). Ama yine de herkes için 19 bayt.

Devam dec ecxetmeden önce yeni yüklediği öğeyle karşılaştırarak başlangıçtan kaçınır . Dış döngünün son yinelemesinde, son elemanı yükler, kendisinden küçük olup olmadığını kontrol eder, sonra yapılır. Bu, BubbleSort'umun başarısız olduğu size = 1 ile çalışmasına izin verir (bunu size = 65536 olarak kabul eder).

Bu arayanı kullanarak bu sürümü (GDB cinsinden) test ettim: Çevrimiçi deneyin! . Bunu TIO'da çalıştırabilirsiniz, ancak elbette hata ayıklayıcı veya yazdırma özelliği yoktur. Yine de, _startbu çağrılar exit-status = biggest element = 99 ile çıkar, böylece çalıştığını görebilirsiniz.

C, 72 bayt

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

BubbleSort. İlk argüman diziye bir göstericidir, ikinci argüman dizinin uzunluğudur. Gcc ile çalışır.

MATL, 11 10 bytes

Y@t!d0>AY)

Extremely inefficient examination of all permutations of the input.

Try it Online!

Explanation

        % 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

Selection sort. Anonymous function; takes the list as argument.

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

This probably won't be the shortest answer but I feel like this algorithm belongs here. call with a list of integers, they'll be printed in a sorted manner to stdout. I wouldn't try it with too large numbers though.

MIPS, 68 bytes

I wrote a simple unoptimized bubble sort implementation a while ago. Byte count begins at loop and ends at li $v0, 10, assuming that the list address and list length are already in memory.

 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

Now I wait to be blown out of the water with 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}

Arrays in awk are like dictionaries, not like C arrays. The indexes can be non-contiguous, and they grow (and are created) as needed. So, we create an array a for the input, with each line being a key. And we save the min and max values. Then we loop from min to max, and print all keys which exist in a. b is just to avoid repeated usage of $0.

Python 3, 91 62 47 bytes

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

Thanks to wnnmaw and Seeq for golfing help.

The argument z should be a list. This is a variant of selection sort.

I'm not sure how min stacks up against built-in sorting functions, since I'm not sure how Python implements min. Hopefully, this solution is still okay. Any golfing suggestions in the comments or in PPCG chat are welcome.

MATL, 11 bytes

`t4#X<2#)tn

Try it online!

This sorts by the following procedure, which is O(n²):

1. Take the minimum of the array.
2. Remove that value from the array, and store it for subsequent display.
3. Apply the same procedure with the rest of the array, until it becomes empty.
4. Display all numbers in the order in which they were obtained.

MATL is stack-based. The array with remaining values is kept at the top of the stack. The removed values are below, in order. At the end of the program all those values are displayed. The array at the top would also be displayed, but since it's empty it's not shown.

`        % 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

Pyth - 15 13 11 10 bytes

Two bytes saved thanks to @Jakube.

Bogosort.

f!s>VTtT.p

Try it online here.

I don't need the h cuz we are guaranteed no duplicates.

Seriously, 6 bytes

,;l@╨m

Try it online!

This does the same thing as many other answers: generate all permutations, select minimum. I kinda forgot that this would work while I was working on the below solution.

Explanation:

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

Seriously, 25 bytes (non-competing)

This would be competitive if it wasn't for a bug in the shuffle command that I just fixed.

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

Try it online! This implements the best sorting algorithm ever: Bogosort!

Explanation:

,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

Saved one byte creating null array thanks to @LuisMendo

vTbtX<-QI$(f8M+q

Bucket sort. Don't try it with a range greater than 2³¹-1.

Try it online!

Explanation

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:

• You can initialize an empty array in MATL using [] and grow it, just like in MATLAB
• How to use ( for assignment indexing
• How to use the M automatic clipboard

New day, new TIL:

• vertcat magically creates an empty array when there's nothing on the stack to concatenate

Julia, 28 27 bytes

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

Try it online!

R, 68 Bytes

Takes input i and outputs o which is the sorted list.

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

Explanation:

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

Avoiding the permutations means it can sort large lists relatively quickly. The "trick" is that subtracting the smallest value from the input leaves a single 0 that determine both the smallest value and the position of the smallest value.

Java 8, 112 92 bytes

Here is another selection sort. The input is a List t of integers and the sorted output is printed to standard out.

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

Update

• -20 [16-08-21] Used a lambda

Retina, 95

Modified bubble sort. I suspect there are much better ways to do this, even without the retina sort builtin.

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

• Stage 1 - convert -ve integers to unary with n as the digit; drop the - signs.
• Stage 2 - convert +ve and zero integers to unary with 1 as the digit; add 1 to each one, so that zero is represented by 1.
• Stage 3 - Move all -ves to the front.
• Stage 4 - Sort: move all -ves with the largest magnitude (i.e. smallest numerical) ahead of higher -ves. Move smaller +ves ahead of larger +ves.
• Stage 5 - Remove 1 from, and convert +ve unaries back to decimal.
• Stage 6 - convert -ve unaries back to decimal, including sign.

Try it online.

Ruby, 22 bytes

A quick permutation sort. Runs in O(n!) space and time.

->a{a.permutation.min}

Clojure, 73 35 bytes

Bogosort :)

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

Earlier version:

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

Reduces to a sorted list r by splitting it into "smaller than i" and "larger than i" parts. I guess this is the insertion sort.

Ruby, 26 24 bytes

Selection sort, similar to Value Ink's answer, but using a different approach for greater golfiness.

According to the specification: "Input/output can be done in any method you choose, as long as it is human readable". I think this fits the description, output is an array of arrays with a single element.

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

example:

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

Here's a good ole bubble sort. The function parameter is modified in place so I don't have to return anything. Still trying to squeeze some bytes out of this so I can beat the java lambda that someone posted.

-1 byte thanks to Geobits for pointing out that normal swapping beats xor'ing
-1 byte thanks to Leaky Nun for pointing out that I can move all the int declarations into the for-loop

Try it online!

Ruby, 22 bytes

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

Builds an array out of the range between the minimum and maximum elements of the input array. Returns the intersection between the two arrays.