我们都知道不同的花式排序算法，但是这些算法都没有以易于发音的方式为我们提供数字。为了解决这个问题，我建议使用VoiceSort™，这是对数字列表进行排序的最自然的方法。

发音

发出数字的正式规则（在此挑战中）是数字被一个一个地发音，并且结果字符串按字典顺序排序。例如，这意味着该数字845是发音的"eight four five"，应进行相应的排序。

负数

负数是通过在单词前面加上字母来发音的"minus"。因此，-23发音为"minus two three"。请注意，这会导致负数最终出现在输出的中间，正好在以4（4）和9（9）开头的数字之间。

作为指导，ForeignSort™的正式词序为：

• 八
• 五
• 四
• 减去
• 九
• 一
• 七
• 六
• 三
• 二
• 零

那是，

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

输入项

范围为的整数列表，最多包含100个元素。不允许输入为字符串列表。如果您的语言不支持输入为列表，则可以将输入作为单独的整数输入。$[-999, 999]$

输入将不包含任何无效数字或任何以0开头的数字（数字本身除外）。输入通常不会排序，可以按任何顺序给出。

输出量

相同的整数，以VoiceSort™顺序排列。请注意，仅应将数字转换为其发音以进行排序，输出不应包含任何字符串。

例子

对于示例，中间步骤（用括号括起来）仅用作指导，而不是输出的一部分。

[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的“数字”）排序，该整数使用魔术字符串“ murgeon lix”中基于1的模块化索引中的字符转换为字符串。

排序实际上是按字母顺序排列的，其中空格被认为小于任何字母。

通过检查压缩中使用的Jelly词典发现了魔术字符串“ murgeon lix”。没有11个字母的单词可以满足要求（重复数据删除也不会满足要求）。由于空格在字母前排序，因此，下一个最明显的选择是长度为7的单词，其后是空格，然后为长度3的单词。“ 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⁶’是21340635的基数250表示，同时Œ?进行计算并将¤这些指令分组在一起）

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（ngn / 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函数和匿名lambda作为密钥。硬编码排序顺序，并将输入列表中每个值中的每个数字与其在排序顺序列表中的位置进行比较。

编辑：通过8从排序列表中删除来节省1个字节，以利用未找到参数时str.find返回的优势-1。多亏了maxb。

Edit2：通过在list文字（而不是list构造函数）中使用加星标的解包语法节省了3个字节

在线尝试！

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)

通过@ngn 及其K答案，通过从字典字符串的开头省略8 节省了1个字节

Japt，19个字节

ñ_s ®n"54-9176320

试试吧

• 由于ETHproductions节省了2个字节。

视网膜0.8.2，36字节

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

在线尝试！链接包括测试套件。说明：

T`-d`3:598217604

将负号和数字按发音顺序转换为它们的位置，使用:第10位。

O`

按发音顺序排序。

T`3:598217604`-d

将订单翻译回原始的减号和数字。

Ruby，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实现。应该多打高尔夫球。

学分

• 凯文·克鲁伊森（Kevin Cruijssen）节省了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 -37 -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。