[Question]
  [
We all know of different fancy sorting algorithms, but none of these give us numbers in a way that's easy to pronounce. To remedy this, I propose using PronunciationSort™, the most natural way to sort lists of numbers.
## Pronunciation
The official rules for pronouncing numbers (in this challenge) is that the digits are pronounced one by one, and the resulting string is sorted in lexicographic order. As an example, this means that the number `845` is pronounced `"eight four five"`, and should be sorted accordingly.
### Negative numbers
Negative numbers are pronounced by prepending the word `"minus"`. Thus, `-23` is pronounced as `"minus two three"`. Note that this causes negative numbers to end up in the middle of the output, right between numbers starting with `4` (four) and `9` (nine).
As a guide, the official order of words for PronunciationSort™ is:
* eight
* five
* four
* minus
* nine
* one
* seven
* six
* three
* two
* zero
That is,
```
8, 5, 4, -, 9, 1, 7, 6, 3, 2, 0
```
## Input
A list of integers in the range \$[-999, 999]\$, containing at most 100 elements. Input as a list of strings is not permitted. If your language does not support input as list, it is permissible to give input as separate integers. 
The input will not contain any invalid numbers, or any number starting with a 0 (except the number 0 itself). The input will generally not be sorted, it can be given in any order.
## Output
The same integers, in PronunciationSort™ order. Note that the numbers should only be converted to their pronunciations to get the sorting, the output should not contain any strings.
## Examples
For the examples, the middle step (wrapped in parentheses) only serves as a guide, and is not a part of the output.
```
[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]
```
There's also a [script for verifying your results](https://tio.run/##XVDLboQwDDyTr7By2aCmqO32re6XoNUKFQNuwYmCYbv9eRpCL@3JM5E9Mxl/kc7xfllo8C4IVKMoVWMDLcrJB8du4nc0nL@qjBpgeIObCLOAMgUGPRBPI2i4@ndwzbnKzi7UIxygPKqsppYkEf2NwWkL2jGuQ86JSRcw8cZNQdvooRua08tIX2ngjLwCpLaTFTBFiSjeuADJAIhhlLDl3fyLynvk2mwBSmLZYH6MCX@/sYNd8eGITbrIlVI8DWvYWEfRk2Co@hPOVW@I/SQmz5UPq9IYO8ParNsWPvFy@NNCXFuW8tbe2b29tw/20T7ZZ/ty/AE).
  
[Answer]
# [Haskell](https://www.haskell.org/), 57 bytes
```
import Data.List
sortOn$map(`elemIndex`"54-9176320").show
```
[Try it online!](https://tio.run/##dY1PC4JAEMXvfoqHeDBYxfVfKdSpixB06CiCS226pJu4G/Xtbeze4c283@MN0wvzkMOwLGqcnrPFUVgRnpSxzn1vKDhrbxST38pBjpW@yU/rZmlQ8G2exJG7CU3/fC8d9lgNQtxJ/izFDWWJi52V7hAcUFfaNhtnFEpTV2krZ3G18PDSg9LS0BW9QUf7x0vNGWKGpHHqgGzEsAY/igjSjKHICTnFnIo8WZWuI/sTM@yaLw "Haskell – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~15~~ 13 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ṾV€ị“Þ⁽3Z6»µÞ
```
**[Try it online!](https://tio.run/##y0rNyan8///hzn1hj5rWPNzd/ahhzuF5jxr3GkeZHdp9aOvhef///4820FGwNAViEx0FEyBtAqR1LUDYEERYxAIA "Jelly – Try It Online")**
A monadic link accepting a list of integers which yields a list of integers.
### How?
Sorts by the ordinal values of the digits of the integers (where `-` is a "digit" of -1) converted to strings using the characters at their 1-based & modular index in the magic string "murgeon lix".
The sort is effectively alphabetic where a space is considered less than any letter.
The magic string "murgeon lix" was found by inspecting Jelly's dictionaries used in compression. There are no words of 11 letters which satisfy the requirements (and none of more that would upon de-duplication). since a space sorts before letters the next most obvious choice is a word of length seven followed by a space followed by a word of length three. "murgeon" and "lix" is the only satisfying combination, although without a space others may be possible (e.g. `“£Py:ƥ»` is "murgeonalix" which works for the same byte-count)
```
Ṿ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")
```
---
[Previous @ 15 bytes](https://tio.run/##y0rNyan8///hzn1hj5rWPNzd/ahhzqGFUfmPGrc9aph5dJL9oSWHth6e9////2gDHQVLUyA20VEwAdImQFrXAoQNQYRFLAA "Jelly – Try It Online"):
```
ṾV€ị“¡Zo⁶’Œ?¤µÞ
```
Here `“¡Zo⁶’Œ?¤` finds the first permutation of natural numbers which would reside at the index 21,340,635 when all permutations of the numbers are sorted lexicographically - which is `[6,10,9,3,2,8,7,1,5,4,11]`. (`“¡Zo⁶’` is a base 250 representation of 21340635, while `Œ?` does the calculation and `¤` groups these instructions together)
[Answer]
# [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/tree/fb4a2ce2bce6660e1a680a74dd61b72c945e6c3b), 15 bytes
```
Σε•Koéa₃•'-3ǝsk
```
[Try it online!](https://tio.run/##MzBNTDJM/W/i9v/c4nNbHzUs8s4/vDLxUVMzkKmua3x8bnH2/9panf/RhjpGOsaxXNG6hjoKBjoKQNIIzDMAckxMdRQszYBcQ6CwoREQG4OwCYgwjQUA "05AB1E (legacy) – Try It Online")
**Explanation**
```
Σ                 # sort by
 ε                # apply to each
             sk   # index of the element in
  •Koéa₃•         # "85409176320"
         '-3ǝ     # with "-" inserted at index 3
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 30 bytes
```
*.sort:{TR/0..9-/a5982176043/}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPtfS684v6jEqjokSN9AT89SVz/R1NLCyNDczMDEWL/2vzVXcWKlQpqGSrymQlp@EVe0oY6CkY6CcawOV7QukG2gowASgXANgDwTUx0FSzMQ3xAoYQhUa2gMwiYgwjTW@j8A "Perl 6 – Try It Online")
Port of G B's Ruby solution.
### Original 35 byte version
```
*.sort: (~*).uninames».&{S/\w*.//}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPtfS684v6jESkGjTktTrzQvMy8xN7X40G49tepg/ZhyLT19/dr/1lzFiZUKaRoq8ZoKaflFXNGGOgpGOgrGsTpc0bpAtoGOAkgEwjUA8kxMdRQszUB8Q6CEIVCtoTEIm4AI01jr/wA "Perl 6 – Try It Online")
Convert each number to a string, get the Unicode name of each character, strip the first word ("DIGIT" or "HYPHEN"), then sort.
[Answer]
# Python 3, ~~68 bytes~~ ~~67 bytes~~ 64 bytes
```
lambda x:sorted(x,key=lambda y:[*map('54-9176320'.find,str(y))])
```
Uses built-in `sorted` function with an anonymous lambda for the key. Hard-code the sort order and compare each digit in each value in the input list to its position in the sort order list.
*Edit: Saved 1 byte by removing `8` from sort list to take advantage of `str.find` returning `-1` when parameter is not found. Thanks to maxb.*
*Edit2: Saved 3 bytes by using starred unpacking syntax in a `list` literal instead of `list` constructor*
[Try it online!](https://tio.run/##XcxBCsMgEAXQfU/hLgqmaNSkCeQkbRcWI5UmRtRFPL1VKIV2YGbx/mdcis/dsqznW17l9lASHFPYfVwUPPBrSfNH07SaEOEmHWwugrcjHXrWkeasjVU4RA8TKpOdNzZCDa8Ugw4Ddkfo9LW2IMGgRn9OCnOBwdj/BLRUaXlDWV1ejyiF/AY "Python 3 – Try It Online")
[Answer]
# [JavaScript (SpiderMonkey)](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/Releases/45), 69 bytes
```
a=>a.sort((a,b)=>(g=n=>[...n+''].map(c=>':598217604'[c]||3))(a)>g(b))
```
[Try it online!](https://tio.run/##bZDNcoMgFIX3fYq7A6ZK/Ilp0xl4EYcFsWhoIzhg0p/Ju1sxOpM6WQAXLnzncD7kRfrK6a6PfafflWut@VQ/Q80Gybik3roeYxkdCOO4YYbxklJqnhEStJUdrhhHb8X@NUtfdskWlZW4XnNCsCS8wQdChsoab0@KnmyDa1ymEWQR5IIQ2Gwg5oBLZI1CEaD@y07L0SmFBAnNcD0fX4inFSYeG0kEgfYP1Wpz9jADf5WbiHf8GRue35wkD9DJSN4WEex3j9kQwLDQa3t2UOvLpGH02Pb6exEKmBtwhK2V0uBi9JDmYWzDVKyDWf4SyjmgqZxCut9A8LE6CaaWINNFp1jEMjH8AQ "JavaScript (SpiderMonkey) – Try It Online")
[Answer]
# [K (ngn/k)](https://bitbucket.org/ngn/k), ~~21 20~~ 22 bytes
```
{x@<"54-9176320"?/:$x}
```
[Try it online!](https://tio.run/##JYrLCsIwEEX3fsVQutBFMJOXJCPof5RA3USkUqF0kVLqr8eJhZnhnnNnEONzLCWFNd@vjTXC48VpJZvbObR5K3NY2275TiFBpv4z0LFPj9ebMi00neJ2mDsEBZoQNKjIKBAksCMOtZK7lBKMBe@I75@8qwXykwLUPIbXUhWV7G5ULD8 "K (ngn/k) – Try It Online")
`{` `}` function with argument `x`
`$` format as strings
`"`...`"?/:` find indices of individual characters in the given string (or \$-2^{63}\$ for not found - note that the `"8"` is missing)
`<` compute sort-ascending permutation
`x@` the argument at those indices
[Answer]
# Pyth, ~~17~~ 16 bytes
```
oxL"54-9176320"`
```
Try it online [here](https://pyth.herokuapp.com/?code=oxL%2254-9176320%22%60&input=%5B-100%2C%2045%2C%2096%5D&debug=0), or verify all the test cases at once [here](https://pyth.herokuapp.com/?code=oxL%2254-9176320%22%60&test_suite=1&test_suite_input=%5B1%2C%202%2C%203%5D%0A%5B-1%2C%200%2C%201%2C%202%5D%0A%5B-100%2C%2045%2C%2096%5D%0A%5B11%2C%2012%2C%2013%2C%20134%2C%20135%5D&debug=0).
```
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)
```
*Saved 1 byte thanks to @ngn and [their K answer](https://codegolf.stackexchange.com/a/172893/41020), by omitting 8 from the start of the dictionary string*
[Answer]
# Japt, 19 bytes
```
ñ_s ®n"54-9176320
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=8V9zIK5uIjU0LTkxNzYzMjA=&input=Wy0xMDAsNDUsOTZd)
* Save 2 bytes thanks to [ETHproductions](https://codegolf.stackexchange.com/users/42545/ethproductions).
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 36 bytes
```
T`-d`3:598217604
O`
T`3:598217604`-d
```
[Try it online!](https://tio.run/##K0otycxL/K@qEZyg8z8kQTclwdjK1NLCyNDczMCEyz@BKwRZACj/PyaPS@e/oY6RjjGXrqGOgQ6QCWQYGOiYmOpYmnEZGuoYGukYGgORCRCbAgA "Retina 0.8.2 – Try It Online") Link includes test suite. Explanation:
```
T`-d`3:598217604
```
Translate the minus sign and digits to their position in pronunciation order, using `:` for 10th position.
```
O`
```
Sort in pronunciation order.
```
T`3:598217604`-d
```
Translate the order back to the original minus sign and digits.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 50 bytes
```
->a{a.sort_by{|x|x.to_s.tr('0-9-','a5982176043')}}
```
[Try it online!](https://tio.run/##HY1BCsMgFET3PYU7W/iKRk3rornIR4JZZFcSjAFD4tmNdjHDvGFgwj4dZf4WNvjT820JcZyO80pX4nEZNx7DkwpmGQXqjf108t0Lregr54IogXRAlANkNQogrfiTqKANENtXlLWWdShVk25mnOM/v7ajx0owwYzJuVxu "Ruby – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 58 bytes
```
function(x)x[order(mapply(chartr,"-0-9","dkfjicbhgae",x))]
```
[Try it online!](https://tio.run/##bZDBboMwDIbvewqLHkikRIJSKiFNfRHEgUIysq5JlcJG@/I0DkRlVQ9J7Nj@ftt2kvDJJznopldGk5GOpbGtsORcXy4/N9J0te0ti3jCi4hF7Ul@q@bYfdUiYiOl1SRJQ1IGWwYZpRvgByBlbLSIGcT9n/FPZ4WIK4rB0uVmLr36wELuvIQB1j@Lz0oPV1gQd2E9Y0VcQFg7CycBljjWLmdQ7N/QAFEQeNIMFqT69VStXPiqxoBGxkwr9jM7RTEnlWZ4dnjl/8YN/aK5jO1NP/raAVR@@cE2wnrSIJIHJber6QE "R – Try It Online")
Input is a list of numbers which is implicitly converted as string using `chartr`. `order` then uses lexigographic order to retrieve the order by which the original list should be sorted.
[Answer]
# [Java (JDK 10)](http://jdk.java.net/), 123 bytes
```
l->l.sort(java.util.Comparator.comparing(n->{var r="";for(var c:(""+n).split(""))r+=11+"54-9176320".indexOf(c);return r;}))
```
[Try it online!](https://tio.run/##dZHJbsIwEIbvPMXIJ7skFmErEBKp4lSpVQ8cqx5c4yDTxI5sBxVVPHtqh660HLzMfL9n847tWbzbvLSyqrVxsPM2bZws6VXa@@MrGsWd1CpAXjJr4Z5JBW89gLp5LiUH65jzx17LDVSe4bUzUm0fn4CZrSWdFGCllW0qYZZ30rrlrXJiK0yeQwFZW8Z5Sa3Pi7/zrnRVM8OcNpR3Vx8Sqzh/2zMDJkMoLbTBweALjFBfEWrrUjp/J8T0syTpo8k4nifX09FwgKhUG/H6UGBOUiNcYxSY9EhIm3bVdUWdVeaEdRYyuDGGHSxlNnDcyeHMmUQwjGBEon9p7PEggiC6qBh4wXgSwXx6QZL454lPkozCGodtcinaLIIZ6RA5tRdG9au7rrnFqcXPHwJYH6wTFdWNo7Wft8OBQx/QAtBHJB@LMs5FfYJf3vOnpfrJj72wju07 "Java (JDK 10) – Try It Online")
This is a naive Java implementation. Should be much golfable.
## Credits
* 3 bytes saved thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)
[Answer]
# [JavaScript (SpiderMonkey)](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/Releases/45), ~~87~~ 73 bytes
```
a=>a.sort((p,q,F=b=>[...""+b].map(x=>"54-9176320".search(x)))=>F(p)>F(q))
```
[Try it online!](https://tio.run/##dY1NDsIgGET3HqMriPMRKNDaGLr0EsYF1vqvYDFGT1/ZuDGazMzmJW@O/uFTNxzinVI8bPrhEq6n/jVu3ehd60UKw52xiBsWbu3apRCiKKbrlbj4yJ6uLayhRtWVLmUhUu@Hbs@enHPXLljkeW6cj/MuXFM49@IcdmzLlgol9IrzyTcgBYlMfzMpYSya6hdVCqqE0jkm1/4xgBrQDFSDKpAFGZAGlfg8Q8PAokKNGRoomUXjGw "JavaScript (SpiderMonkey) – Try It Online")
Thanks @Arnauld for telling that the sort in SpiderMonkey is stable, so the `||-(F(q)>F(p))` part can finally be dropped.
[Answer]
# [Red](http://www.red-lang.org), 114 bytes
```
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]]
```
[Try it online!](https://tio.run/##VYzNCsIwEITvPsXQkx6KSf@0RfAdvIY9lHRTi21SYoX69DEoiMIO8813WM9duHCnaGOaYB5WK0uqb/DGlpR248h6UcZ5bvUVGpEmtOrGPGOwHa9nmNjJsSzSWh6qPBOJJqK788teu2luPcN@Hq54ktr2WHcn9JEpzH6wCwyURIacNt@dSghE@aeEQFGirn6klJAZZB6viCkpvAA "Red – Try It Online")
## More readable:
```
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 ]
]
```
[Answer]
# C++, 353 bytes
This is kind of a comedy entry, but I was wasting time and wrote it, so I can't not post it... Enjoy a chuckle, and let me know if there are any space-savers I missed!
```
#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," "));}
```
Output:
> 
> 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
> 
> 
> 
[Answer]
# Mathematica, 68 bytes
```
SortBy[If[# < 0,"m ",""]<>StringRiffle@IntegerName@IntegerDigits@#&]
```
Function. Takes a list of integers as input and returns the sorted list as output. Just separates the digits of each number with `IntegerDigits`, converts each digit to `"zero"`, `"one"`, etc., with `IntegerName`, converts the list into a space-separated string with `StringRiffle`, prepends an `"m "` if the number is negative, and sorts based on this string. Indeed, this was the shortest approach I can find, since Mathematica only natively uses lexicographic sorting for lists of the same length; thus, an approach based on `854-9176320` ends up taking more bytes since string functions are so expensive.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~15~~ ~~14~~ 13 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
Σ•t∍ýJ•(ÁÁsSk
```
-1 byte thanks to *@Emigna*.  
-1 byte thanks to *@ovs*.
[Try it online](https://tio.run/##yy9OTMpM/f//3OJHDYtKHnX0Ht7rBWRpHG483FgcnP3/f7ShoY6hkY6hMRCZALFpLAA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfeX/c4sfNSwqedTRe3ivF5ClcbjxcGNxcPb/Wp3/0dGGOkY6xrE6CtG6hjoGOkAehG1goGNiqmNpBuIZGuoYGukYGgORCRCbxsYCAA).
**Explanation:**
```
Σ              # Sort by:
 •t∍ýJ•        #  Push compressed integer 917632054
       (       #  Negate it: -917632054
        ÁÁ     #  Rotate it twice towards the right: "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')
```
[See this 05AB1E tip of mine (section *How to compress large integers*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `•t∍ýJ•` is `917632054`.
[Answer]
# [Nim](http://nim-lang.org/), 110 109 105 103 bytes
```
import algorithm,sequtils,strutils
func p[S](n:S):S=n.sortedByIt join mapIt($it,$"54-9176320".find(it))
```
[Try it online!](https://tio.run/##Vcw7C4NADAfw3U8RxEEhiuezCoXSzdlRHMRHveI96p1DP709Swc7JITfPwmnbN8pk2LV0C0PsVI9M1Tja9N0Uaj0@h2saeM9yKZuXV7WXllfeaDMzTjc35WGp6AcWCcr7TpUo2OniV@QPIuj0A4mygeXas/bx34WcGsIQoQQt4G0fuIbChGO4E9Dg0mKUGQnJmaNmAckPio5WnqKc4SLuTCyfwA "Nim – Try It Online")
For some reason, Nim can't compare `seq`s, so I had to turn the results into a string, which cost quite a lot of bytes.
]