Змагання

Насправді це дуже просто, сортуйте список номерів.

Деталі

Ви повинні сортувати список номерів у порядку зростання, не використовуючи вбудованих функцій сортування / бібліотек / тощо (тобто list.sort()в Python).

Введення / виведення можна виконати будь-яким обраним вами методом, якщо це читається людиною.

Стандартні лазівки заборонено, як завжди.

Виграє найкоротший код у байтах.

Ви повинні пояснити / перелічити, який метод сортування ви використовували (Bubble, Insertion, Selection, etc.)

Введення не буде містити дублікатів.

Зразок вводу / виводу

Вхід: 99,-2,53,4,67,55,23,43,88,-22,36,45

Вихід: -22,-2,4,23,36,43,45,53,55,67,88,99

Примітка. Близька пряма протилежність сортування списку чисел

05AB1E , 2 байти

Код:

ϧ

Той самий алгоритм, що і відповідь Джелі . Обчислює всі перестановки вхідних даних і вискакує найменшу.

Спробуйте в Інтернеті!

Більш ефективним методом є:

E[ß,Ž

Виконує вибір . Використовує кодування CP-1252 .

Спробуйте в Інтернеті!

Желе, 3 байти

Œ!Ṃ

Це генерує всі перестановки вхідного списку, а потім вибирає лексографічно найменшу перестановку. Дуже ефективний.

Подяка @Adnan, який мав таку ж ідею незалежно.

Спробуйте в Інтернеті!

Желе, 4 байти

ṂrṀf

Це будує діапазон від мінімуму списку до максимуму списку, а потім відкидає елементи діапазону, відсутні у вихідному списку. Це технічно це відро , з дуже маленькими відрами. Мені невідома назва цього конкретного варіанту.

Спробуйте в Інтернеті!

Як це працює

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

Пітон, 46 45 байт

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

Простий вибір сортування.

Брахілог , 12 7 байт

p.'(s>)

Тут використовується сортування перестановки, що, очевидно, страшно, але ей, це коротше, ніж Pyth!

Пояснення

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 байт

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

Двійкова функція %вставляє новий елемент hу відсортований список tшляхом розподілу tна префікс aелементів <hта суфікс bелементів >hта вставляє hміж ними.

Потім операція foldr(%)[]створює відсортований список із порожнього, повторно вставляючи елементи зі списку вхідних даних.

Це на один байт коротше, ніж пряма рекурсивна реалізація

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

Ще одна стратегія на 41 байт:

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

JavaScript (ES6), 51 байт

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

Кожна петля знаходить найменше число, яке досі не знайдено.

Python 2, 34 байти

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

Приймає введення як набір, друкуючи його елементи в порядку порядку, закінчуючи помилкою.

Чисте припинення можна виконати в 41 байті:

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

або

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

Вхід може прийматись як список на 39 байт або 38 байт у 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 байт

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

Прокручує всі цілі числа (на моїй машині підписані 64-бітні) і зберігає ті, що є u. Звичайно, це не закінчується в розумні строки.

Попередня версія, прокручена через [minimum u..maximum u]яку має той самий гірший час роботи.

Редагувати: @xnor зберег байт. Спасибі!

Oracle SQL 11.2, 205 байт

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

Без гольфу

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)          

Щодо методу сортування, я не маю уявлення, ORDER BYпереконавшись, що забув їх.

машинний код x86-16 (BubbleSort int8_t), 20 19 байт

x86-64 / 32 код машини (JumpDownSort) 21 19 байт

Журнал змін:

• Дякуємо @ ped7g за lodsb/ cmp [si],alідею та додає це разом із збільшенням / скиданням вказівника, на яке я дивився. Не потребуючи al/ ahдозволяє нам використовувати майже той самий код для більших цілих чисел.

• Новий (але пов’язаний з цим) алгоритм, безліч змін реалізації: Bubbly SelectionSort дозволяє меншу реалізацію x86-64 для байтів або dwords; беззбитковість на x86-16 (байти чи слова). Також уникає помилок на розмір = 1, який має мій BubbleSort. Дивись нижче.

• Виявляється, мій Bubbly Selection Sort зі свопами кожного разу, коли ви знайдете новий хв - це вже відомий алгоритм, JumpDown Sort. Він згадується у сортуванні бульбашок: археологічний алгоритмічний аналіз (тобто як сортування бульбашок стало популярним, незважаючи на смоктання).

Сортує 8-бітні цілі числа на місці . (Непідписаний - той самий розмір коду, просто змініть jgeна a jae). Дублікати - це не проблема. Ми обміняємось, використовуючи 16-бітове поворот на 8 (з призначенням пам'яті).

Bubble Sort відстійний для продуктивності , але я читав, що це один з найменших для впровадження машинного коду. Це здається особливо актуальним, коли існують спеціальні хитрощі для заміни сусідніх елементів. Це майже єдина його перевага, але іноді (в реальному житті вбудованих систем) достатньо переваги, щоб використовувати його для дуже коротких списків.

Я пропустив дострокове припинення без будь-яких свопів . Я використав "оптимізований" цикл BubbleSort у Вікіпедії, який уникає перегляду останніх n − 1елементів під час запуску втретє n, тому лічильник зовнішнього циклу є верхньою межею для внутрішнього циклу.

Список NASM ( nasm -l /dev/stdout) або звичайне джерело

 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 cxнавколо внутрішнього циклу означає, що він працює з cx= external_cx до 0.

Зауважте, що rol r/m16, imm8це не інструкція 8086, вона була додана пізніше (186 або 286), але це не намагається бути 8086 кодом, лише 16-бітним x86. Якщо SSE4.1 phminposuwдопоможе, я би використовував його.

32-розрядна версія цього (все ще працює на 8-бітових цілих числах, але з 32-бітовими покажчиками / лічильниками) становить 20 байт (префікс розміру операнду включений rol word [esi-1], 8)

Помилка: size = 1 трактується як розмір = 65536, тому що ніщо не заважає нам увійти до зовнішнього do / while з cx = 0. (Ви зазвичай використовуєте jcxzдля цього.) Але, на щастя, 19-байтовий JumpDown Sort має 19 байт і не має такої проблеми.

Оригінальна версія 20-байт x86-16 (без ідеї Ped7g). Пропущено для економії місця, перегляньте історію редагування для нього з описом.

Продуктивність

Частково перекриваюче зберігання / перезавантаження (у повороті до місця призначення пам'яті) спричиняє затримку переадресації магазину на сучасних процесорах x86 (крім Atom порядку). Коли високе значення кидається вгору, ця додаткова затримка є частиною ланцюга залежностей, перенесених циклом. Зберігати / перезавантажувати смоктання в першу чергу (як, наприклад, 5 циклів затримки переадресації магазину на Haswell), але стійла переадресації приводять його приблизно до 13 циклів. Виконання поза замовлення матиме труднощі приховати це.

Дивіться також: Переповнення стека: сортування міхурів для сортування рядків для версії цієї програми з аналогічною реалізацією, але з достроковою програмою, коли заміни не потрібні. Він використовує xchg al, ah/ mov [si], axдля заміни, що на 1 байт довше і викликає зупинку часткового реєстру на деяких процесорах. (Але це все ж може бути краще, ніж обертання пам’яті, яке потрібно знову завантажити). У моєму коментарі є кілька пропозицій ...

x86-64 / x86-32 Сортувати JumpDown, 19 байт (сортування int32_t)

Викликається з C, використовуючи умовний виклик системи V x86-64 як V
int bubblyselectionsort_int32(int dummy, int *array, int dummy, unsigned long size); (значення повернення = max (масив [])).

Це https://en.wikipedia.org/wiki/Selection_sort , але замість того, щоб запам'ятати положення елемента min, поміняйте поточний кандидат у масив . Після того, як ви знайшли хв (неортирований_регіон), збережіть його до кінця відсортованої області, як звичайний Сортування вибору. Це зростає відсортовану область по одному. (У коді rsiвказує на один минулий кінець відсортованої області; lodsdпросуває його та mov [rsi-4], eaxзберігає хв назад у нього.)

Назва Сортувати вниз по сорту використовується в Bubble Sort: Археологічний алгоритмічний аналіз . Я думаю, мій сорт - це справді стрибок вгору, тому що високі елементи стрибають вгору, залишаючи знизу відсортовану, а не кінець.

Цей дизайн обміну призводить до того, що несортована частина масиву закінчується в основному зворотно відсортованим порядком, що призводить до пізніх змін. (Тому що ви починаєте з великого кандидата і продовжуєте бачити все нижчих та нижчих кандидатів, тому ви продовжуєте міняти місцями.) Я назвав це "бульбашково", хоча він переміщує елементи в іншому напрямку. Спосіб переміщення елементів також трохи схожий на сортування назад. Щоб переглянути його в дії, використовуйте GDB display (int[12])buf, встановіть точку перерви у внутрішній loopінструкції та використовуйте c(продовжуйте). Натисніть клавішу return, щоб повторити. (Команда "display" дає GDB друкувати весь стан масиву кожного разу, коли ми потрапляємо на точку зламу).

xchgУ mem є неявний lockпрефікс, який робить це надзвичайно повільним. Можливо, приблизно на порядок повільніше, ніж ефективний своп / зберігання; xchg m,r- це одна пропускна здатність 23c на Skylake, але завантаження / зберігання / mov з tmp reg для ефективної заміни (reg, mem) може зміщувати один елемент на такт. Це може бути гіршим співвідношенням у процесорі AMD, де loopінструкція швидка, і не буде вузьким місцем внутрішнього циклу, але пропуски гілок все ще будуть великим вузьким місцем, оскільки заміни є звичайними (і стають більш поширеними, коли несортірованная область стає меншою ).

 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

Однаковий розмір код int8_t: використання lodsb/ scasb, ALі змінити [rsi/rdi-4]до -1. Цей же машинний код працює в 32-бітному режимі для 8/32-бітних елементів. 16-бітний режим для 8/16-бітних елементів повинен бути відтворений із зміненими зміщеннями (а 16-бітні режими адреси використовують інше кодування). Але все ж 19 байт для всіх.

Він уникає початкового dec ecxшляхом порівняння з елементом, який він щойно завантажив, перш ніж рухатися далі. Під час останньої ітерації зовнішньої петлі він завантажує останній елемент, перевіряє, чи не менше він себе, то робиться. Це дозволяє йому працювати з size = 1, де мій BubbleSort виходить з ладу (трактує його як розмір = 65536).

Я протестував цю версію (в GDB) за допомогою цього абонента: Спробуйте в Інтернеті! . Ви можете запустити це на TIO, але звичайно без налагодження чи друку. І все-таки те, _startщо викликає, завершує роботу з вихідним статусом = найбільшим елементом = 99, тож ви можете бачити, що це працює.

C, 72 байти

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

Бульбашок. Перший аргумент - вказівник на масив, другий аргумент - довжина масиву. Працює з gcc.

MATL , 11 10 байт

Y@t!d0>AY)

Надзвичайно неефективна перевірка всіх перестановок вводу.

Спробуйте в Інтернеті!

Пояснення

        % 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

Рубін, 40 байт

Вибір сортування. Анонімна функція; приймає список як аргумент.

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

Пітон, 120 байт

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]

Це, мабуть, не буде найкоротшою відповіддю, але я відчуваю, що цей алгоритм тут належить. зателефонуйте зі списком цілих чисел, вони будуть роздруковані в упорядкованому порядку для stdout. Я б не намагався це зробити із занадто великою кількістю.

MIPS, 68 байт

Я писав просту неоптимізовану реалізацію сортування бульбашок деякий час тому. Кількість байтів починається з loopі закінчується в li $v0, 10, припускаючи, що адреса списку та довжина списку вже є в пам'яті.

 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

Тепер я чекаю, коли його видують з води з x86 ...

Awk, 66 байт

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

Масиви в awk схожі на словники, а не як масиви C. Індекси можуть бути безперервними, і вони ростуть (і створюються) у міру необхідності. Отже, ми створюємо масив aдля введення даних, кожен рядок є ключовим. І ми зберігаємо значення min і max. Потім обводимо від мінімуму до максимуму і друкуємо всі клавіші, які існують у a. bце просто уникати повторного використання $0.

Пітон 3, 91 62 47 байт

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

Завдяки wnnmaw та Seeq за допомогу в .

Аргумент z має бути список. Це варіант сортування селекції.

Я не впевнений, як minпротиставляється built-in sorting functions, оскільки я не впевнений, як Python реалізує min. Сподіваємось, це рішення все-таки добре. Будь-які пропозиції щодо гольфу в коментарях або в чаті PPCG вітаються.

MATL , 11 байт

`t4#X<2#)tn

Спробуйте в Інтернеті!

Це сортується за наступною процедурою, яка є O ( n ² ):

1. Візьміть мінімум масиву.
2. Видаліть це значення з масиву та збережіть його для подальшого відображення.
3. Застосовуйте ту саму процедуру з рештою масиву, поки він не стане порожнім.
4. Відобразити всі числа в тому порядку, в якому вони були отримані.

MATL заснований на стеці. Масив із залишковими значеннями зберігається у верхній частині стека. Видалені значення знаходяться внизу, по порядку. В кінці програми відображаються всі ці значення. Масив у верхній частині також відображатиметься, але оскільки він порожній, він не відображається.

`        % 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 байт

Два байти збережено завдяки @Jakube.

Богоссор.

f!s>VTtT.p

Спробуйте його онлайн тут .

Мені не потрібно, тому що hми не гарантуємо копій.

Серйозно, 6 байт

,;l@╨m

Спробуйте в Інтернеті!

Це робить те саме, що і багато інших відповідей: генеруйте всі перестановки, виберіть мінімум. Я якось забув, що це буде працювати, поки я працював над рішенням нижче.

Пояснення:

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

Серйозно, 25 байт (неконкуренто)

Це було б конкурентоспроможно, якби не помилка в команді перетасовки, яку я щойно виправив.

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

Спробуйте в Інтернеті! Це реалізує найкращий алгоритм сортування коли-небудь: Bogosort !

Пояснення:

,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 байт

Збережено один байт, створюючи нульовий масив завдяки @LuisMendo

vTbtX<-QI$(f8M+q

Сорт відра. Не спробуйте з діапазоном більше 2 ³¹ -1.

Спробуйте в Інтернеті!

Пояснення

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:

• Ви можете ініціалізувати порожній масив у MATL за допомогою [] та наростити його, як у MATLAB
• Як користуватись ( для індексації призначення
• Як користуватися Mавтоматичним буфером обміну

Новий день, новий TIL:

• vertcat магічно створює порожній масив, коли в стеку немає нічого, що об'єднує

Юлія, 28 27 байт

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

Спробуйте в Інтернеті!

R, 68 байт

Бере вхід iі вихід, oякий є відсортованим списком.

o<-i
for(j in 1:length(i)){
x<-(i-min(i))==0
o[j]<-i[x]
i<-i[!x]
}
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

Уникнення перестановок означає, що він може сортувати великі списки порівняно швидко. «Трюк» полягає в тому, що віднімання найменшого значення з вхідного сигналу залишає єдине 0, яке визначає як найменше значення, так і положення найменшого значення.

Java 8, 112 92 байт

Ось ще один сортовий сорт. Вхід є List tцілими числами і відсортований вихід друкується для стандартного виходу.

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

Оновлення

• -20 [16-08-21] Використовується лямбда

Сітківка, 95

Модифікований сорт міхура. Я підозрюю, що є набагато кращі способи зробити це навіть без вбудованої сітківки.

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

• Етап 1 - перетворити -ve цілі числа в одинакові з nцифрою; скидають -знаки.
• Етап 2 - перетворити + ve та нульові цілі числа в одинакові з 1цифрою; додайте 1до кожного, щоб нуль був представлений символом 1.
• Етап 3 - переміщення всіх -вперед.
• Етап 4 - Сортування: переміщення all -ves з найбільшою величиною (тобто найменшою числовою) попереду вищих -ves. Перемістіть менше + ves перед більшими + ves.
• Етап 5 - Вилучіть 1 з і перетворіть + уній назад у десятковий.
• Етап 6 - перетворити -вернутий уніар в десятковий, включаючи знак.

Спробуйте в Інтернеті.

Рубін, 22 байти

Швидка перестановка роду. Працює в O (n!) Просторі та часі.

->a{a.permutation.min}

Clojure, 73 35 байт

Богосорт :)

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

Більш рання версія:

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

Зменшує до відсортованого списку r, розділяючи його на частини "менші за i" та "більші за i". Я здогадуюсь, це такий тип вставки .

Рубі, 26 24 байти

Вибір сорту, подібний до відповіді Value Ink, але використовуючи інший підхід для більшої гольфності.

Відповідно до специфікації: "Введення / виведення можна виконати будь-яким обраним вами методом, якщо воно читається людиною". Я думаю, що це відповідає опису, вихід - це масив масивів з одним елементом.

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

приклад:

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

Java 7, 106 104 байт

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

Ось хороший сорт бульбашки з олею. Параметр функції змінено на місці, тому мені нічого не потрібно повертати. Ще намагаюся вичавити з цього кілька байт, щоб я міг бити ямб-лямбду, яку хтось розмістив.

-1 байт завдяки Geobits за те, що він зазначив, що нормальна заміна б'є xor'ing
-1 байт завдяки Leaky Nun за те, що вона зазначила, що я можу перемістити всі декларації int у фор -циклі

Спробуйте в Інтернеті!

Рубін, 22 байти

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

Побудовує масив поза діапазоном між мінімальним та максимальним елементами вхідного масиву. Повертає перетин між двома масивами.