Все мы знаем о различных причудливых алгоритмах сортировки, но ни один из них не дает нам чисел таким образом, который легко произносить. Чтобы исправить это, я предлагаю использовать PronuationSort ™, наиболее естественный способ сортировки списков чисел.

Произношение

Официальные правила произнесения чисел (в этом вызове) таковы, что цифры произносятся одна за другой, а полученная строка сортируется в лексикографическом порядке. В качестве примера это означает, что число 845произносится "eight four five"и должно быть соответственно отсортировано.

Отрицательные числа

Отрицательные числа произносятся путем добавления слова "minus". Таким образом, -23произносится как "minus two three". Обратите внимание, что это приводит к тому, что отрицательные числа оказываются в середине вывода, прямо между числами, начинающимися с 4(четыре) и 9(девять).

В качестве руководства официальный порядок слов для произношенияSort ™:

• восемь
• 5
• четыре
• минус
• 9
• один
• Семь
• шесть
• три
• два
• нуль

То есть,

8, 5, 4, -, 9, 1, 7, 6, 3, 2, 0

вход

Список целых чисел в диапазоне , содержащий не более 100 элементов. Ввод в виде списка строк не допускается. Если ваш язык не поддерживает ввод в виде списка, допустимо указывать ввод в виде отдельных целых чисел.$[-999, 999]$

Входные данные не будут содержать недопустимых чисел или любых чисел, начинающихся с 0 (кроме самого числа 0). Входные данные, как правило, не сортируются, они могут быть заданы в любом порядке.

Выход

Те же самые целые числа, в порядке произношенияSort ™. Обратите внимание, что числа должны быть преобразованы только в их произношение, чтобы получить сортировку, выходные данные не должны содержать строк.

Примеры

В примерах средний шаг (заключенный в скобки) служит только руководством и не является частью вывода.

[1, 2, 3] -> (['one', 'two', 'three']) -> [1, 3, 2]
[-1, 0, 1, 2] -> (['minus one', 'zero', 'one', 'two']) -> [-1, 1, 2, 0]
[-100, 45, 96] -> (['minus one zero zero', 'four five', 'nine six']) -> [45, -100, 96]
[11, 12, 13, 134, 135] -> (['one one', 'one two', 'one three', 'one three four', 'one three five']) -> [11, 13, 135, 134, 12]

Есть также скрипт для проверки ваших результатов .

05AB1E (наследие) , 15 байтов

Σε•Koéa₃•'-3ǝsk

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

объяснение

Σ                 # sort by
 ε                # apply to each
             sk   # index of the element in
  •Koéa₃•         # "85409176320"
         '-3ǝ     # with "-" inserted at index 3

Haskell , 57 байт

import Data.List
sortOn$map(`elemIndex`"54-9176320").show

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

Желе ,  15  13 байт

ṾV€ị“Þ⁽3Z6»µÞ

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

Монадическая ссылка, принимающая список целых чисел, которая выдает список целых чисел.

Как?

Сортирует по порядковым значениям цифр целых чисел (где -это «цифра» -1), преобразованных в строки с использованием символов с их модульным индексом на основе 1 в магической строке «murgeon lix».

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

Волшебная строка «murgeon lix» была найдена при проверке словарей желе, используемых для сжатия. Нет слов из 11 букв, которые удовлетворяют требованиям (и ни одного из них больше, чем при дедупликации). так как пробел сортируется перед буквами, следующим наиболее очевидным выбором является слово длиной семь, за которым следует пробел, за которым следует слово длины три. «murgeon» и «lix» - единственная удовлетворяющая комбинация, хотя без пробела возможны и другие (например “£Py:ƥ», «murgeonalix», который работает с тем же количеством байтов)

ṾV€ị“Þ⁽3Z6»µÞ - Link: list of integers
            Þ - sort by:
           µ  -   the monadic link: -- i.e. do this for each integer, then sort by that
Ṿ             -     unevaluate  (e.g. -803 -> ['-','8','0','3'])
 V€           -     evaluate each as Jelly code  (e.g. ['-','8','0','3'] -> [-1,8,0,3])
    “Þ⁽3Z6»   -     "murgeon lix" (compression of words in Jelly's dictionary plus a space)
   ị          -     index into (1-indexed & modular) (e.g. [-1,8,0,3] -> "i xr")

Предыдущие @ 15 байтов :

ṾV€ị“¡Zo⁶’Œ?¤µÞ

Здесь “¡Zo⁶’Œ?¤находится первая перестановка натуральных чисел, которая будет находиться в индексе 21 340 635, когда все перестановки чисел отсортированы лексикографически - что есть [6,10,9,3,2,8,7,1,5,4,11]. ( “¡Zo⁶’является базовым представлением 250 для 21340635, в то время как Œ?выполняется вычисление и ¤группирует эти инструкции вместе)

Perl 6 , 30 байт

*.sort:{TR/0..9-/a5982176043/}

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

Порт GB решение Ruby.

Оригинальная 35-байтовая версия

*.sort: (~*).uninames».&{S/\w*.//}

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

Преобразуйте каждое число в строку, получите имя Unicode для каждого символа, удалите первое слово («DIGIT» или «HYPHEN»), а затем сортируйте.

JavaScript (SpiderMonkey) , 69 байт

a=>a.sort((a,b)=>(g=n=>[...n+''].map(c=>':598217604'[c]||3))(a)>g(b))

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

K (нгн / к) , 21 20 байт

{x@<"54-9176320"?$x}

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

{ } функция с аргументом x

$ форматировать как строки

""?$-2^{63}$"8"

< вычислить сортировку по возрастанию перестановки

x@ аргумент в этих показателях

Python 3, 68 байт 67 байт 64 байта

lambda x:sorted(x,key=lambda y:[*map('54-9176320'.find,str(y))])

Использует встроенную sortedфункцию с анонимной лямбдой для ключа. Жестко запрограммируйте порядок сортировки и сравните каждую цифру в каждом значении в списке ввода с ее позицией в списке порядка сортировки.

Редактировать: 1 байт был сохранен путем удаления 8из списка сортировки, чтобы воспользоваться возможностью str.findвозврата, -1когда параметр не найден. Благодаря MaxB.

Edit2: сохранены 3 байта, используя помеченный синтаксис в listлитерале вместо listконструктора

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

Pyth, 17 16 байт

oxL"54-9176320"`

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

oxL"54-9176320"`NQ   Implicit: Q=eval(input())
                     Trailing N, Q inferred
o                Q   Order the elements of Q, as N, using...
               `N      Convert N to string
 xL                    Get the index of each character of that string...
   "54-9176320"        ... in the lookup ordering
                       (if character missing, returns -1, so 8 is still sorted before 5)

Сохранено 1 байт благодаря @ngn и их K-ответу , пропуская 8 в начале строки словаря

Japt, 19 байт

ñ_s ®n"54-9176320

Попытайся

• Сохраните 2 байта благодаря ETHproductions .

Сетчатка 0.8.2 , 36 байт

T`-d`3:598217604
O`
T`3:598217604`-d

Попробуйте онлайн! Ссылка включает тестовый набор. Объяснение:

T`-d`3:598217604

Переведите знак минус и цифры в их положение в порядке произношения, используя :для 10-й позиции.

O`

Сортировка в порядке произношения.

T`3:598217604`-d

Переведите заказ обратно в исходный знак минус и цифры.

Рубин , 50 байтов

->a{a.sort_by{|x|x.to_s.tr('0-9-','a5982176043')}}

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

R , 58 байт

function(x)x[order(mapply(chartr,"-0-9","dkfjicbhgae",x))]

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

Ввод представляет собой список чисел, который неявно преобразуется в виде строки с использованием chartr. orderзатем использует лексикографический порядок, чтобы получить порядок сортировки исходного списка.

Java (JDK 10) , 123 байта

l->l.sort(java.util.Comparator.comparing(n->{var r="";for(var c:(""+n).split(""))r+=11+"54-9176320".indexOf(c);return r;}))

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

Это наивная реализация Java. Должно быть много в гольф.

кредиты

• 3 байта сэкономлено благодаря Кевину Круйссену

JavaScript (SpiderMonkey) , 87 73 байта

a=>a.sort((p,q,F=b=>[...""+b].map(x=>"54-9176320".search(x)))=>F(p)>F(q))

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

Спасибо @Arnauld за сообщение о том, что сортировка в SpiderMonkey стабильна, так что ||-(F(q)>F(p))часть может быть окончательно отброшена.

Красный , 114 байт

func[n][g: func[a][collect[foreach c form a[keep index? find"854-9176320"c]]]sort/compare n func[x y][(g x)< g y]]

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

Более читабельно:

f: func [ n ] [
    g: func [ a ] [
        collect [ 
            foreach c form a [ 
                keep index? find "854-9176320" c
            ]
        ]
    ]
    sort/compare n func [ x y ] [ (g x) < g y ]
]

C ++, 353 байта

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

#include<algorithm>
#include<iostream>
#include<iterator>
#include<numeric>
#include<string>
using namespace std;auto f(int i){auto s=to_string(i);for(auto&c:s)c='A'+"854-9176320"s.find(c);return s;}int main(){int a[100];auto b=begin(a);auto e=end(a);iota(b,e,-50);sort(b,e,[](int l,int r){return f(l)<f(r);});copy(b,e,ostream_iterator<int>(cout," "));}

Выход:

8 5 4 48 45 44 49 41 47 46 43 42 40 -8 -5 -50 -4 -48 -45 -44 -49 -41 -47 -46 -43 -42 -40 -9 -1 -18 -15 - 14 -19 -11 -17 -16 -13 -12 -10 -7 -6 -3 -38 -35 -34 -39 -31 -31 -36 -36 -33 -32 -30 -2 -28 -25 -24 - 29 -21 -27 -26 -23 -22 -20 9 1 18 15 14 19 11 17 16 13 12 10 7 6 3 38 35 34 39 31 37 36 33 32 30 2 28 25 24 29 21 27 26 23 22 20 0

Mathematica, 68 байт

SortBy[If[# < 0,"m ",""]<>StringRiffle@IntegerName@IntegerDigits@#&]

Функция. Принимает список целых чисел в качестве входных данных и возвращает отсортированный список в качестве выходных данных. Просто разделяет цифры каждого числа с помощью IntegerDigits, преобразует каждую цифру в "zero", "one"и т. Д., С помощью IntegerName, преобразует список в строку, разделенную пробелами, с StringRiffleдобавлением, "m "если число является отрицательным, и сортирует на основе этой строки. Действительно, это был самый короткий подход, который я могу найти, поскольку Mathematica использует лексикографическую сортировку только для списков одинаковой длины; таким образом, подход, основанный на том, 854-9176320что занимает больше байтов, так как строковые функции очень дороги.

05AB1E , 15 14 байтов

Σ•ĆU‘•…54-ìsSk

-1 байт благодаря @Emigna .

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

Σ                 # Sort by:
 •ĆU‘•            #  Push the compressed integer 9176320
      …54-        #  Push the string "54-"
          ì       #  Prepend this string before the integer: "54-9176320"
           s      #  Swap so the current number to sort is at the top of the stack
            S     #  Convert it to a list of characters
             k    #  Check for each its index in the string (resulting in -1 for '8')

Посмотрите эту подсказку 05AB1E (раздел Как сжать большие целые числа ), чтобы понять, почему •ĆU‘•это так 9176320.