Соревнование

Это довольно просто, сортируйте список чисел.

Детали

Вы должны отсортировать список чисел в порядке возрастания, без использования каких-либо встроенных функций сортировки / библиотек / и т. Д. (Например, list.sort()в Python).

Ввод / вывод может быть выполнен любым способом, который вы выберете, при условии, что он удобочитаем.

Стандартные лазейки запрещены как всегда.

Самый короткий код в байтах побеждает.

Вы должны объяснить / перечислить, какой метод сортировки вы использовали (Bubble, Insertion, Selection и т. Д.)

На входе не будет дубликатов.

Пример ввода / вывода

Входные данные: 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.

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

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)          

Что касается метода сортировки, я понятия не имею, ORDER BYудостоверился, что забыл их.

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

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

Changelog:

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

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

• Оказывается, что моя Bubbly Selection Sort с перестановками каждый раз, когда вы находите новый мин, уже является известным алгоритмом JumpDown Sort. Это упоминается в Bubble Sort: Археологический Алгоритмический Анализ (то есть, как Bubble Sort стал популярным, несмотря на сосание).

Сортирует 8-битные целые числа со знаком на месте . (Без знака имеет тот же размер кода, просто изменить jgeк 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.

Пуш / поп 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 рассматривается как size = 65536, потому что ничто не мешает нам войти во внешнюю do / while с cx = 0. (Вы обычно используете jcxzдля этого.) Но, к счастью, 19-байтовая сортировка JumpDown занимает 19 байтов и не имеет этой проблемы.

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

Спектакль

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

См. Также: Переполнение стека: пузырьковая сортировка для сортировки строки для версии с аналогичной реализацией, но с ранним выходом, когда не требуется перестановок. Он использует xchg al, ah/ mov [si], axдля перестановки, которая на 1 байт длиннее и вызывает остановку частичного регистра на некоторых процессорах. (Но это может все же быть лучше, чем memory-dst rotate, который должен снова загрузить значение). Мой комментарий там есть некоторые предложения ...

x86-64 / x86-32 JumpDown Sort, 19 байт (сортирует int32_t)

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

Это https://en.wikipedia.org/wiki/Selection_sort , но вместо запоминания позиции элемента min, поменяйте местами текущий кандидат в массив . Как только вы нашли min (unsorted_region), сохраните его в конце отсортированной области, как в обычной сортировке выбора. Это увеличивает отсортированный регион на единицу. (В коде rsiуказывает на один конец конца отсортированного региона; lodsdон перемещается вперед и mov [rsi-4], eaxсохраняет мин. Обратно в него.)

Название «Прыжок вниз» используется в Bubble Sort: археологический алгоритмический анализ . Я полагаю, что мой вид - это тип Jump Up, потому что высокие элементы прыгают вверх, оставляя отсортированным нижний, а не конец.

Такая схема обмена приводит к тому, что несортированная часть массива заканчивается в основном в обратном порядке, что впоследствии приводит к множеству перестановок. (Потому что вы начинаете с большого кандидата и продолжаете видеть все более и более низкого кандидата, поэтому вы продолжаете менять местами.) Я назвал его «пузырьковым», даже если он перемещает элементы в другом направлении. То, как он перемещает элементы, также немного похоже на обратную вставку-сортировку. Чтобы посмотреть его в действии, используйте GDB display (int[12])buf, установите точку останова на внутренней loopинструкции и используйте c(продолжить). Нажмите возврат, чтобы повторить. (Команда «display» заставляет GDB печатать состояние целого массива каждый раз, когда мы достигаем точки останова).

xchgУ mem есть неявный lockпрефикс, который делает это очень медленным. Вероятно, примерно на порядок медленнее, чем эффективный обмен загрузкой / хранением; xchg m,rэто одна пропускная способность на 23c на Skylake, но загрузка / сохранение / перемещение с регистром tmp для эффективного обмена (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 не работает (обрабатывает его как size = 65536).

Я проверил эту версию (в GDB) с помощью этого абонента: попробуйте онлайн! , Вы можете запустить его на TIO, но, конечно, нет отладчика или печати. Тем не менее, тот, _startкоторый вызывает его, завершается с exit-status = наибольшим элементом = 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];}

BubbleSort. Первый аргумент - это указатель на массив, второй аргумент - это длина массива. Работает с 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}

Python, 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 похожи на словари, а не на массивы Си. Индексы могут быть несмежными, и они растут (и создаются) по мере необходимости. Итак, мы создаем массив aдля ввода, где каждая строка является ключом. И мы сохраняем минимальное и максимальное значения. Затем мы выполняем цикл от минимума до максимума и печатаем все ключи, которые существуют в a. bэто просто, чтобы избежать повторного использования $0.

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

Bogosort.

f!s>VTtT.p

Попробуйте онлайн здесь .

Мне не нужно, hпотому что мы гарантируем, что нет дубликатов.

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

,;l@╨m

Попробуйте онлайн!

Это делает то же самое, что и многие другие ответы: генерировать все перестановки, выбирать минимум. Я забыл, что это сработает, пока я работаю над приведенным ниже решением.

Объяснение:

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

Серьезно, 25 байт (не конкурирующих)

Это было бы конкурентоспособно, если бы не ошибка в команде shuffle, которую я только что исправил.

,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автоматическим буфером обмена

Новый день, новый ТИЛ:

• 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 - Сортировка: передвиньте все звездочки с наибольшей величиной (то есть наименьшим численным значением) впереди высших. Двигайтесь меньше + вес впереди большего + вес.
• Этап 5 - Удалить 1 из и преобразовать + ve унарные обратно в десятичную.
• Этап 6 - преобразование -ve унарных обратно в десятичное, включая знак.

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

Рубин, 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путем разбиения его на части «меньше, чем я» и «больше, чем я». Я думаю, это сортировка вставки .

Рубин, 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;}}

Вот хорошая оле пузырьковая сортировка. Параметр функции изменен на месте, поэтому мне не нужно ничего возвращать. Все еще пытаюсь выжать из этого несколько байтов, чтобы я смог превзойти Java-лямбду, которую кто-то опубликовал.

-1 байт, спасибо Geobits за указание на то, что обычная замена бьет xor'ing
-1 байт благодаря Leaky Nun за указание, что я могу переместить все объявления int в цикл for

Попробуйте онлайн!

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

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

Создает массив из диапазона между минимальным и максимальным элементами входного массива. Возвращает пересечение между двумя массивами.