Wyzwanie

To naprawdę bardzo proste, posortuj listę liczb.

Detale

Musisz posortować listę liczb w porządku rosnącym, bez korzystania z wbudowanych funkcji sortujących / bibliotek / etc (tj. list.sort()W Pythonie).

Wejścia / wyjścia można wykonać dowolną wybraną metodą, o ile jest to czytelne dla człowieka.

Standardowe luki są jak zwykle niedozwolone.

Najkrótszy kod w bajtach wygrywa.

Musisz wyjaśnić / wymienić zastosowaną metodę sortowania (Bubble, Insertion, Selection itp.)

Dane wejściowe nie będą zawierać duplikatów.

Przykładowe wejście / wyjście

Wkład: 99,-2,53,4,67,55,23,43,88,-22,36,45

Wydajność: -22,-2,4,23,36,43,45,53,55,67,88,99

Uwaga: prawie bezpośrednie przeciwieństwo sortowania listy liczb

05AB1E , 2 bajty

Kod:

ϧ

Ten sam algorytm co odpowiedź Jelly . Oblicza wszystkie permutacje danych wejściowych i wyskakuje najmniejszy.

Wypróbuj online!

Bardziej wydajną metodą jest:

E[ß,Ž

Dokonuje sortowania wyboru . Wykorzystuje kodowanie CP-1252 .

Wypróbuj online!

Galaretka, 3 bajty

Œ!Ṃ

Generuje to wszystkie permutacje z listy danych wejściowych, a następnie wybiera najmniejszą leksykograficzną permutację. Bardzo wydajny

Kredyty dla @Adnan, który miał ten sam pomysł niezależnie.

Wypróbuj online!

Galaretka, 4 bajty

ṂrṀf

To buduje zakres od minimum listy do maksimum listy, a następnie odrzuca elementy zakresu nieobecne na oryginalnej liście. Technicznie jest to rodzaj łyżki , z bardzo małymi łyżkami. Nie znam nazwy tego konkretnego wariantu.

Wypróbuj online!

Jak to działa

Ṃ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 bajtów

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

Prosty wybór sortowania.

Brachylog , 12 7 bajtów

p.'(s>)

Używa to sortowania permutacyjnego, co jest oczywiście okropne, ale hej, jest krótsze niż Pyth!

Wyjaśnienie

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 bajtów

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

Funkcja binarna %wstawia nowy element hdo posortowanej listy t, dzieląc tgo na prefiks aelementów <hi sufiks belementów >hi wsuwając się hmiędzy nimi.

Operacja foldr(%)[]następnie tworzy posortowaną listę z pustych przez wielokrotne wstawianie elementów z listy wejściowej.

Jest to jeden bajt krótszy niż bezpośrednia rekurencyjna implementacja

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

Kolejna strategia dla 41 bajtów:

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

JavaScript (ES6), 51 bajtów

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

Każda pętla znajduje najmniejszą liczbę, która dotychczas nie została znaleziona.

Python 2, 34 bajty

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

Pobiera dane wejściowe jako zestaw, drukuje elementy w porządku rosnącym, kończąc z błędem.

Czyste zakończenie można wykonać w 41 bajtach:

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

lub

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

Dane wejściowe można traktować jako listę dla 39 bajtów lub 38 bajtów w Pythonie 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 bajtów

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

Pętle przechodzą przez wszystkie liczby całkowite (podpisane 64-bitowe, na moim komputerze) i zatrzymują te, które są u. Oczywiście nie kończy się w rozsądnym czasie.

Poprzednia wersja była zapętlona i [minimum u..maximum u]ma ten sam najgorszy czas działania.

Edycja: @xnor zapisał bajt. Dzięki!

Oracle SQL 11.2, 205 bajtów

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

Nie grał w golfa

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)          

Jeśli chodzi o metodę sortowania, nie mam pojęcia, ORDER BYupewniłem się, że je zapomniałem.

kod maszynowy x86-16 (BubbleSort int8_t), 20 19 bajtów

Kod maszynowy x86-64 / 32 (JumpDownSort) 21 19 bajtów

Dziennik zmian:

• Dziękuję @ ped7g za pomysł lodsb/ cmp [si],ali łącząc to ze zwiększaniem / resetowaniem wskaźnika, na który patrzyłem. Nie potrzebujemy al/ ahpozwala nam używać prawie tego samego kodu dla większych liczb całkowitych.

• Nowy (ale pokrewny) algorytm, wiele zmian implementacyjnych: Bubbly SelectionSort pozwala na mniejszą implementację x86-64 bajtów lub dwordów; break-even na x86-16 (bajty lub słowa). Pozwala także uniknąć błędu rozmiaru = 1, który ma mój BubbleSort. Patrz poniżej.

• Okazuje się, że mój Bubbly Selection Sort z zamianą za każdym razem, gdy znajdziesz nową min, jest już znanym algorytmem, JumpDown Sort. Jest wspomniany w Bubble Sort: An Archeological Algorytmic Analysis (tj. Jak Bubble Sort stał się popularny pomimo ssania).

Sortuje 8-bitowe liczby całkowite ze znakiem na miejscu . (Unsigned ma ten sam rozmiar kodu, wystarczy zmienić na jgea jae). Duplikaty nie stanowią problemu. Zamieniamy za pomocą 16-bitowego obrotu o 8 (z miejscem docelowym pamięci).

Sortowanie bąbelkowe wymaga wydajności , ale przeczytałem, że jest to jedna z najmniejszych możliwości implementacji w kodzie maszynowym. Wydaje się to szczególnie prawdziwe, gdy istnieją specjalne triki do zamiany sąsiednich elementów. Jest to w zasadzie jego jedyna zaleta, ale czasami (w prawdziwych systemach wbudowanych) jest to wystarczająca zaleta, aby użyć jej do bardzo krótkich list.

Pominąłem wcześniejsze zakończenie bez zamiany . Użyłem „zoptymalizowanej” pętli BubbleSort z Wikipedii, która unika oglądania ostatnich n − 1elementów podczas biegu po nraz -ty, więc licznik pętli zewnętrznej jest górną granicą dla pętli wewnętrznej.

Lista NASM ( nasm -l /dev/stdout) lub zwykłe źródło

 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 cxwokół wewnętrznej pętli oznacza, że ​​działa z cx= outer_cx w dół do 0.

Zauważ, że rol r/m16, imm8nie jest to instrukcja 8086, została dodana później (186 lub 286), ale nie jest to próba kodu 8086, tylko 16-bitowy x86. Jeśli phminposuwpomoże SSE4.1 , skorzystam z niego.

Wersja 32-bitowa (wciąż działająca na 8-bitowych liczbach całkowitych, ale z 32-bitowymi wskaźnikami / licznikami) ma 20 bajtów (prefiks wielkości operandu włączony rol word [esi-1], 8)

Błąd: rozmiar = 1 jest traktowany jako rozmiar = 65536, ponieważ nic nie powstrzymuje nas przed wejściem do zewnętrznego do / while z cx = 0. (Zazwyczaj jcxzużywałbyś do tego.) Ale na szczęście 19-bajtowy Sort JumpDown ma 19 bajtów i nie ma tego problemu.

Oryginalna 20-bajtowa wersja x86-16 (bez pomysłu Ped7g). Pominięto, aby zaoszczędzić miejsce, zobacz historię edycji z opisem.

Wydajność

Częściowo zachodzące na siebie zapisywanie / przeładowanie (w rotacji miejsca docelowego w pamięci) powoduje zatrzymanie przekazywania magazynu na nowoczesnych procesorach x86 (z wyjątkiem Atomu w kolejności). Kiedy wysoka wartość rośnie w górę, to dodatkowe opóźnienie jest częścią łańcucha zależności przenoszonego przez pętlę. Przechowywanie / przeładowywanie jest w pierwszej kolejności zasysane (np. 5-cyklowe opóźnienie przekazywania do sklepu w Haswell), ale przeciągnięcie przekazywania powoduje więcej niż 13 cykli. Wykonanie poza kolejnością będzie miało problem z ukryciem tego.

Zobacz także: Przepełnienie stosu: sortowanie bąbelkowe do sortowania łańcucha dla wersji tego z podobną implementacją, ale z wczesnym wyprzedzeniem, gdy nie są potrzebne żadne zamiany. Używa xchg al, ah/ mov [si], axdo zamiany, która jest dłuższa o 1 bajt i powoduje częściowe zatrzymanie rejestru na niektórych procesorach. (Ale wciąż może być lepszy niż rotacja pamięci-dst, która musi ponownie załadować wartość). Mój komentarz zawiera kilka sugestii ...

x86-64 / x86-32 JumpDown Sort, 19 bajtów (sortuje int32_t)

Można wywoływać z C przy użyciu konwencji wywoływania Systemu x86-64 jako V
int bubblyselectionsort_int32(int dummy, int *array, int dummy, unsigned long size); (wartość zwracana = maks. (Tablica [])).

Jest to https://en.wikipedia.org/wiki/Selection_sort , ale zamiast zapamiętywać pozycję elementu min, zamień bieżącego kandydata na tablicę . Po znalezieniu min (region nieposortowany) zapisz go na końcu posortowanego regionu, tak jak normalne sortowanie selekcji. To powiększa posortowany region o jeden. (W kodzie rsiwskazuje jeden za końcem posortowanego regionu; lodsdprzesuwa go i mov [rsi-4], eaxzapisuje min w nim).

Nazwa Sortuj w dół jest używana w Sortowaniu bąbelkowym: archeologiczna analiza algorytmiczna . Wydaje mi się, że mój rodzaj jest naprawdę rodzajem skoku w górę, ponieważ wysokie elementy podskakują w górę, pozostawiając posortowane dno, a nie koniec.

Ten projekt wymiany prowadzi do tego, że nieposortowana część tablicy kończy się w większości w odwrotnej kolejności, co prowadzi do wielu zamian w późniejszym czasie. (Ponieważ zaczynasz od dużego kandydata i ciągle widzisz niższych i niższych kandydatów, więc ciągle zamieniasz się.) Nazwałem to „bąbelkowym”, mimo że przesuwa elementy w innym kierunku. Sposób, w jaki przesuwa elementy, jest również trochę podobny do odwrotnego sortowania. Aby obejrzeć go w akcji, użyj GDB display (int[12])buf, ustaw punkt przerwania w wewnętrznej loopinstrukcji i użyj c(kontynuuj). Naciśnij Return, aby powtórzyć. (Polecenie „display” powoduje, że GDB wypisuje cały stan tablicy za każdym razem, gdy osiągamy punkt przerwania).

xchgwith mem ma niejawny lockprzedrostek, co powoduje, że jest to bardzo wolne. Prawdopodobnie o rząd wielkości wolniejszy niż efektywna zamiana obciążenia / magazynu; xchg m,rto jedna na przepustowość 23c na Skylake, ale ładowanie / przechowywanie / mov z regem tmp dla wydajnej wymiany (reg, mem) może przesunąć jeden element na zegar. Może to być gorszy współczynnik na procesorze AMD, w którym loopinstrukcja jest szybka i nie spowodowałaby tak dużego ograniczenia wewnętrznej pętli, ale pominięcia gałęzi nadal będą dużym wąskim gardłem, ponieważ wymiany są powszechne (i stają się częstsze, gdy nieposortowany region staje się mniejszy ).

 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

Sam rozmiar kod int8_t: Używaj lodsb/ scasb, ALi zmienić [rsi/rdi-4]na -1. Ten sam kod maszynowy działa w trybie 32-bitowym dla elementów 8/32-bitowych. Tryb 16-bitowy dla 8/16-bitowych elementów musi zostać odbudowany ze zmienionymi przesunięciami (a 16-bitowe tryby adresowania używają innego kodowania). Ale wciąż 19 bajtów dla wszystkich.

Unika początkowej dec ecxpoprzez porównanie z elementem, który właśnie załadował przed przejściem dalej. Podczas ostatniej iteracji zewnętrznej pętli ładuje ostatni element, sprawdza, czy jest mniejszy niż on sam, a następnie jest wykonywany. To pozwala mu pracować z rozmiarem = 1, gdzie mój BubbleSort zawodzi (traktuje go jako rozmiar = 65536).

Testowałem tę wersję (w GDB) przy użyciu tego wywołującego: Wypróbuj online! . Możesz uruchomić to na TIO, ale oczywiście nie ma debugera ani drukowania. Mimo to, to, _startco go wywołuje, kończy działanie z parametrem exit-status = największy element = 99, więc widać, że działa.

C, 72 bajty

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. Pierwszy argument jest wskaźnikiem do tablicy, drugi argument to długość tablicy. Działa z gcc.

MATL , 11 10 bajtów

Y@t!d0>AY)

Niezwykle nieefektywne badanie wszystkich permutacji danych wejściowych.

Wypróbuj online!

Wyjaśnienie

        % 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

Rubinowy, 40 bajtów

Sortuj wybór. Funkcja anonimowa; przyjmuje listę jako argument.

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

Python, 120 bajtów

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]

To prawdopodobnie nie będzie najkrótsza odpowiedź, ale wydaje mi się, że ten algorytm należy tutaj. wywołanie z listą liczb całkowitych, zostaną wydrukowane w uporządkowany sposób na standardowe wyjście. Jednak nie spróbowałbym tego przy zbyt dużych liczbach.

MIPS, 68 bajtów

Jakiś czas temu napisałem prostą, niezoptymalizowaną implementację sortowania bąbelkowego. Liczba bajtów zaczyna się loopi kończy o li $v0, 10, zakładając, że adres i długość listy są już w pamięci.

 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

Teraz czekam na wysadzenie z wody za pomocą x86 ...

Awk, 66 bajtów

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

Tablice w awk są jak słowniki, a nie jak tablice C. Indeksy mogą być nieciągłe i rosną (i są tworzone) w razie potrzeby. Tak więc tworzymy tablicę adla danych wejściowych, przy czym każda linia jest kluczem. I zapisujemy wartości minimalną i maksymalną. Następnie zapętlamy od min do maksimum i wypisujemy wszystkie klucze, które istnieją a. bjest po to, aby uniknąć wielokrotnego używania $0.

Python 3, 91 62 47 bajtów

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

Dzięki wnnmaw i Seeq za pomoc w grze w golfa.

Argumentem zpowinna być lista. Jest to wariant sortowania selekcji.

Nie jestem pewien, jak minradzi sobie z tym built-in sorting functions, ponieważ nie jestem pewien, jak implementuje się Python min. Mamy nadzieję, że to rozwiązanie jest nadal w porządku. Wszelkie sugestie dotyczące gry w golfa w komentarzach lub na czacie PPCG są mile widziane.

MATL , 11 bajtów

`t4#X<2#)tn

Wypróbuj online!

Sortuje to według następującej procedury, którą jest O ( n ² ):

1. Weź minimum tablicy.
2. Usuń tę wartość z tablicy i zapisz ją do późniejszego wyświetlenia.
3. Zastosuj tę samą procedurę do reszty tablicy, aż stanie się pusta.
4. Wyświetl wszystkie liczby w kolejności, w jakiej zostały uzyskane.

MATL jest oparty na stosie. Tablica z pozostałymi wartościami znajduje się na górze stosu. Usunięte wartości są poniżej, w kolejności. Pod koniec programu wyświetlane są wszystkie te wartości. Wyświetlona zostanie również tablica u góry, ale ponieważ jest pusta, nie jest wyświetlana.

`        % 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 bajtów

Dwa bajty zapisane dzięki @Jakube.

Bogosort.

f!s>VTtT.p

Wypróbuj online tutaj .

Nie potrzebuję, hponieważ gwarantujemy, że nie będzie duplikatów.

Poważnie, 6 bajtów

,;l@╨m

Wypróbuj online!

Robi to samo, co wiele innych odpowiedzi: wygeneruj wszystkie permutacje, wybierz minimum. Trochę zapomniałem, że to zadziała, gdy pracuję nad poniższym rozwiązaniem.

Wyjaśnienie:

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

Poważnie, 25 bajtów (niekonkurujących)

Byłoby to konkurencyjne, gdyby nie błąd, który właśnie naprawiłem.

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

Wypróbuj online! To implementuje najlepszy algorytm sortowania: Bogosort !

Wyjaśnienie:

,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 bajtów

Zaoszczędzono jeden bajt, tworząc tablicę zerową dzięki @LuisMendo

vTbtX<-QI$(f8M+q

Sortowanie wiader. Nie próbuj z zakresem większym niż 2 ³¹ -1.

Wypróbuj online!

Wyjaśnienie

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:

• Możesz zainicjować pustą tablicę w MATL-u za pomocą []i rozwijać ją, tak jak w MATLAB
• Jak używać (do indeksowania przypisań
• Jak korzystać z Mautomatycznego schowka

Nowy dzień, nowy TIL:

• vertcat magicznie tworzy pustą tablicę, gdy na stosie nie ma nic do połączenia

Julia, 28 27 bajtów

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

Wypróbuj online!

R, 68 bajtów

Pobiera dane wejściowe ii wyjściowe, októre są posortowaną listą.

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

Wyjaśnienie:

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

Unikanie permutacji oznacza, że ​​może stosunkowo szybko sortować duże listy. „Sztuczka” polega na tym, że odjęcie najmniejszej wartości od danych wejściowych pozostawia pojedyncze 0, które określa zarówno najmniejszą wartość, jak i pozycję najmniejszej wartości.

Java 8, 112 92 bajty

Oto kolejny wybór. Dane wejściowe są List tliczbami całkowitymi, a posortowane dane wyjściowe są wypisywane na standardowe wyjście.

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

Aktualizacja

• -20 [16-08-21] Używany lambda

Retina, 95

Zmodyfikowano sortowanie bąbelkowe. Podejrzewam, że są na to znacznie lepsze sposoby, nawet bez wbudowanego sortowania siatkówki.

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

• Etap 1 - konwertuje -ve liczby całkowite na unary z ncyfrą; upuść -znaki.
• Etap 2 - konwersja liczb całkowitych + ve i zero na unarne z 1cyfrą; dodaj 1do każdego, tak aby zero było reprezentowane przez 1.
• Etap 3 - Przenieś wszystkie -ves na przód.
• Etap 4 - Sortuj: przesuń all -ves o największej wielkości (tj. Najmniejszej wartości liczbowej) przed wyższym -ves. Przesuń mniejszy + pęcherz przed większym + pęcherzem.
• Etap 5 - Usuń 1 z i przekonwertuj + ve unariów z powrotem na dziesiętne.
• Etap 6 - konwersja -ve jednostek jednorzędowych z powrotem na dziesiętne, w tym znak.

Wypróbuj online.

Ruby, 22 bajty

Szybkie permutacji sortowania. Działa w przestrzeni O (n!) I czasie.

->a{a.permutation.min}

Clojure, 73 35 bajtów

Bogosort :)

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

Wcześniejsza wersja:

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

Zmniejsza do posortowanej listy r, dzieląc ją na części „mniejsze niż i” i „większe niż i”. To chyba rodzaj wstawiania .

Ruby, 26 lat 24 bajtów

Sortuj według wyboru, podobnie jak w przypadku Value Ink, ale stosując inne podejście dla większej golfisty.

Zgodnie ze specyfikacją: „Wejście / wyjście można wykonać dowolną wybraną metodą, o ile jest to czytelne dla człowieka”. Myślę, że pasuje to do opisu, wynikiem jest tablica tablic z jednym elementem.

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

przykład:

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

Java 7, 106 104 bajtów

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

Oto dobry rodzaj bąbelków. Parametr funkcji został zmodyfikowany na miejscu, więc nie muszę nic zwracać. Wciąż próbuję wycisnąć z tego kilka bajtów, abym mógł pokonać javę lambda, którą ktoś opublikował.

-1 bajt dzięki Geobits za wskazanie, że normalna zamiana bije xor'ing
-1 bajt dzięki Leaky Nun za wskazanie, że mogę przenieść wszystkie deklaracje int do pętli for

Wypróbuj online!

Ruby, 22 bajty

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

Tworzy tablicę poza zakresem między minimalnymi i maksymalnymi elementami tablicy wejściowej. Zwraca przecięcie dwóch tablic.