[Question]
  [
# Challenge:
Given a list of integer, sort descending by their single largest digit(s). The order for numbers with the same largest digit are then sorted by second largest digit, etc.  
We ignore duplicated digits in numbers. And if all digits in a number are the same, the order of those numbers in the list can be in any way you'd like.
**Example:**
```
Input:            [123, 478, -904, 62778, 0, -73, 8491, 3120, 6458, -7738, 373]
Possible outputs: [8491, -904, 62778, 478, -7738, 6458, 373, -73, 3120, 123, 0]
                  [8491, -904, 62778, 478, -7738, 6458, -73, 373, 3120, 123, 0]
```
Why? Here are the relevant digits the numbers were sorted on:
```
Output:
[8491,  -904,  62778,   478,     -7738,   6458,  373,   -73,   3120,      123,     0  ]
Relevant digits they were sorted on:
[[9,8], [9,4], [8,7,6], [8,7,4], [8,7,3], [8,6], [7,3], [7,3], [3,2,1,0], [3,2,1], [0]]
```
## Challenge rules:
* We ignore duplicated digits, so `478` and `-7738` will be ordered as `478, -7738`, because the largest digits are `[8,7,4]` and `[8,7,3]`, and not `[8,7,4]` and `[8,7,7,3]`.
* If multiple numbers have the same digits, the order of those can be either way. So `373` and `-73` can be sorted as both `373, -73` or `-73, 373` (digits are `[7,3]` for both of these numbers).
* If a number contains no more digits to check, it will be placed at the back of the relevant numbers. So `123` and `3120` will be sorted as `3120, 123`, because the largest digits `[3,2,1]` are the same, but `0` comes before *`none`*.
* You can assume all numbers in the input are in the range `[-999999,999999]`.
* Just one of the possible outputs is enough as result, but you are allowed to output all possible outputs where sublists can be in any permutation if you want (although I doubt it would save bytes in any language).
## General rules:
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins.  
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
* [Standard rules apply](https://codegolf.meta.stackexchange.com/questions/2419/default-for-code-golf-program-function-or-snippet/2422#2422) for your answer with [default I/O rules](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/), so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
* [Default Loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
* If possible, please add a link with a test for your code (i.e. [TIO](https://tio.run/#)).
* Also, adding an explanation for your answer is highly recommended.
## Test cases:
```
Input:            [123, 478, -904, 62778, 0, -73, 8491, 3120, 6458, -7738, 373]
Possible outputs: [8491, -904, 62778, 478, -7738, 6458, 373, -73, 3120, 123, 0]
                  [8491, -904, 62778, 478, -7738, 6458, -73, 373, 3120, 123, 0]
Input:            [11, -312, 902, 23, 321, 2132, 34202, -34, -382]
Possible outputs: [902, -382, 34202, -34, -312, 321, 2132, 23, 11]
                  [902, -382, 34202, -34, 2132, -312, 321, 23, 11]
                  etc. The sublist [-312, 321, 2132] can be in any permutation
Input:            [9, 44, 2212, 4, 6, 6, 1, 2, 192, 21, 29384, 0]
Possible outputs: [29384, 192, 9, 6, 6, 4, 44, 2212, 21, 2, 1, 0]
                  [29384, 192, 9, 6, 6, 44, 4, 2212, 21, 2, 1, 0]
                  etc. The sublists [4, 44] and [2212, 21] can be in any permutation
Input:            [44, -88, 9, 233, -3, 14, 101, 77, 555, 67]
Output:           [9, -88, 67, 77, 555, 14, 44, 233, -3, 101]
```
  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes
```
ΣêR}R
```
[Try it online!](https://tio.run/##yy9OTMpM/f//3OLDq4Jqg/7/jzYx0VHQtbDQUbDUUTAyNgZygNgQKGhoYKijYG6uo2BqaqqjYGYeCwA "05AB1E – Try It Online")
or as a [Test suite](https://tio.run/##HU09CkIxDN49RXBuoU3Sl3bxLeIBHgjC4w0KDk4Ozp7GzQN4AN29Uv0ilDTfb6634@ly7rrb7vv38XlO96kfxjXFDa3H8H6Nfc4sgdRqoNiSBhrYHCRgg1K15UCSGcSgxW1mgk9MltWcIUaogVrC8C5hcJwFUJSdjaI@KiPQcAyI2TN@7v88gdm8wvcmFVqC382x4l7zdvEeGEHmBKNZoFIKOmz5AQ)
**Explanation**
```
Σ  }    # sort input by
 ê      # its sorted unique characters
  R     # reversed (to sort descending)
    R   # reverse the result (to sort descending)
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 9 bytes
```
{ȧdṫo₁}ᵒ¹
```
Note: due to how ordering works in brachylog, it does not work on number correctly. This is fixed by casting the number to a string (`ṫ`) at the cost of 1 byte.
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r/v/rE8pSHO1fnP2pqrH24ddKhnf//RxsaGesomJhb6CjEWxqY6CiYGZmDOAZAvjlQxsLE0lBHwdjQCChgZmIKUmZubgykjM2NY/9HAQA "Brachylog – Try It Online")
[Answer]
# [R](https://www.r-project.org/), ~~97~~ 95 bytes
```
function(x)x[rev(order(sapply(Map(sort,Map(unique,strsplit(paste(x),"")),T),Reduce,f=paste0)))]
```
[Try it online!](https://tio.run/##LU3LasQwDLz3K8yeLFDAsZy1fdhP6KX0VnoIWQcCS@LaTtl@fSqFBTOWRvMox3w75n2d2rKt@gnPr5J@9Vbuqeg65vz40@9j1nUrDWXY1@VnT1hbqfmxNJ3H2hL78HIBwE/Aj3Tfp4Tz7bwYAPg@Zj3p3hIq5wOqLhqH6mq9LIZ3z5fgYo@KesvE1Q0i8574I08Ab2cCCzpWoIqGQfLIMmd74pWcFbYjJxDsyxS5lBlrxSe15xMXY5QYmSMFvpmXRwxd4O4oLSR5LGayNyz2HtUwDJzjAY5/ "R – Try It Online")
This challenge seems to have been pessimized for R. Explanation of the original version (start at 1. and work up):
```
f <- function(x) {
  x[                                                  # 8. Input vector in
    rev(                                              # 7. Reversed
        order(                                        # 6. Lexicographical order
              sapply(                                 # 5. Paste....
                     Map(sort,                        # 4. Sort each using...
                              Map(unique,             # 3. Deduplicate each
                                  strsplit(           # 2. Split each string into characters
                                           paste(x),  # 1. Coerce each number to string
                                           "")),      
                         T),                          # 4. ...descending sort.
                     paste,collapse="")               # 5. ...back into strings
              )
        )
    ]
}
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~36~~ ~~34~~ ~~33~~ 31 bytes
*-1 byte thanks to Jo King*  
*-2 bytes thanks to Phil H*
```
*.sort:{sort 1,|set -<<m:g/\d/}
```
[Try it online!](https://tio.run/##HU1LCsIwEN17ilmIqCSazKSdxM9JVESwdaMorRtRz17fCOU17zuPprvWw@1Fk5a2w3zR37vn6m1I0X365kl@s7mtLsv9efkd1qP@9KJ2Oj7OqL13o11kcZQ0O/IlJEc1q5EArnByKtGRRIZQp8piqoKfqBwc6nA9bEclAGxMGBpHAZXEpnpJBpmtUXAOlNlKdvD/WQVYbMPeRTK8YAVL@4yTxfbFlpCEGAOSqo6qqsKIHoYf "Perl 6 – Try It Online")
### Explanation
```
       {                      }  # Map each number, e.g. -373
                       m:g/\d/  # Extract digits: (3, 7, 3)
                    -<<  # Negate each digit: (-3, -7, -3)
                set  # Convert to set to remove duplicates
               |  # Pass as list of pairs: (-3 => True, -7 => True)
             1,  # Prepend 1 for "none": (1, -3 => True, -7 => True)
        sort  # Sort (compares 1 and pair by string value): (-7 => True, -3 => True, 1)
*.sort:  # Sort lexicographically
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~58~~ 60 bytes
`lambda a:sorted(a,key=lambda x:sorted(set(`x`))[::-1])[::-1]`
[Try it online!](https://tio.run/##VY7dCsIwDIXvfYpebtBCm3SmHfgkKmziRPFvzF3o088TmYhQ8nOS7zT9azzebzQdVpvp0l53@9a09eM@jN2@aO25e61m9flVH91YNM@mLNd17cJ2TlM/nG5jcSjWgdiaKMkal320ZkmijUcvmKSYgzUcCMIyVromwkgsvC3Lxc8Haw571mSPoK5M0CgwWo6kquOoIdEfmnEAdCKl9YTPUxYxq5nWmRNm/o9UzCVck/VHVm8gEIMHImJNVVVwE1DTGw)
[Answer]
# Pyth, ~~7~~ 6 bytes
*-1 byte by [@Sok](https://codegolf.stackexchange.com/users/41020/sok)*
```
_o_{S`
```
Pyth, which uses only printable ASCII, is at a bit of a disadvantage here. Optimally encoded this would be `6*log(95)/log(256) = 4.927` bytes, beating 05AB1E.
Explained:
```
 o              Sort the implicit input by lambda N:
  _               reversed
   {               uniquified
    S               sorted
     '               string representation [of N]
_               then reverse the result.
```
Try it [here](http://pyth.herokuapp.com/?code=_o_%7BS%60&input=%5B123%2C+478%2C+-904%2C+62778%2C+0%2C+-73%2C+8491%2C+3120%2C+6458%2C+-7738%2C+373%5D&test_suite=1&test_suite_input=%5B123%2C+478%2C+-904%2C+62778%2C+0%2C+-73%2C+8491%2C+3120%2C+6458%2C+-7738%2C+373%5D%0A%5B11%2C+-312%2C+902%2C+23%2C+321%2C+2132%2C+34202%2C+-34%2C+-382%5D%0A%5B9%2C+44%2C+2212%2C+4%2C+6%2C+6%2C+1%2C+2%2C+192%2C+21%2C+29384%2C+0%5D%0A%5B44%2C+-88%2C+9%2C+233%2C+-3%2C+14%2C+101%2C+77%2C+555%2C+67%5D&debug=0).
[Answer]
# [Python 2](https://docs.python.org/2/), ~~60~~ ~~55~~ 54 bytes
-1 byte thanks to [Jonas Ausevicius](https://codegolf.stackexchange.com/users/83921/jonas-ausevicius).
```
def f(l):l.sort(cmp,lambda n:sorted(set(`n`))[::-1],1)
```
[Try it online!](https://tio.run/##bY7BisMwDETv@QodE7AXW3IqO7BfUgrtblJ2wU1Dm0u/PjtqTwsFI1sjzfMsj/XnOvO2jdOZzm3thvpxv97W9vuyuHq6fI0nmgdTprG9T2t7nI9dtx8GHw8udlulT9pHFkdJsyNfQnK0Y7UmoFdMcirRkUSGsEu9rakKLlE5NPZps9x@55Vq07x4WPfYd1QCitGFoXEUtJLYVC/JSua3iIJAmDMbxSI9jzFQi0HtXSRjFt4SzO4zUhZLIPYXrBBjgFXVUd/3oOp/9/YH "Python 2 – Try It Online")
---
## Ungolfed
```
def f(l):
  l.sort(        # Sort the list in place
    cmp = cmp,   # ... compare with the builtin function cmp
    key = k,     # ... on the function k
    reverse = 1  # ... in reverse
  )              # As the arguments are used in the right order, no names are necessary.
k = lambda n:sorted( # sort  
  set(`n`)           # ... the set of digits
  )[::-1]            # reverse the result
                     # As '-' is smaller than the digits,
                     # it will be sorted to the back and ignored for sorting
```
[Try it online!](https://tio.run/##dVLBbqswELzzFSv10EQyCGxSINI7vG/osapUBwyxMDayTat8fboLaaVIqYWMd3dmdhYzX@LZWX69dqqHfmf2xwTAZMH5uIPbeoJXDCGeFRgdImgLs5GtSqjYTjP8o52tyCzLoHXTLL2CLx3PK@u0aBOR1S@2jdpZgq/kUV2QPLJbGyJjlSi/0HEFevWpfFAILn6AqHfLImIPd@sJ/odVRvphmZSNAcjQElRHPKp4PZwjON8pz8A6sHJSG8qqVoUg/SVLkhE7GjmdOgn2SB9FdTtUpxMA9g0q7j7sx/6uN7mjFlgE10OnBx0DmXw7HtPi/d7oz2SrJxUWExN4tNaRntNn0AHCJI1RHjlyG2Zrwf5i6oh3YQycFGwzQHTbxch2BGnxowzWecz3zq8QbYerwdnfCi4YlFXNIG3yksELryjIMa6wUpdNwUAUHBMv5YFgVSXwJSrxntD/lMxe2wgmSTY9hKeIZ9DkuJG64JjjhcBQlJyyqShpq/lDiQYNYZ1zUiFL60MauDckSudG1FjLHyoQPa3RZUMOBPVCKiaLHKlVxeBwOKBqdc@@fgM "Python 2 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes
```
ADṢUQµÞU
```
[Try it online!](https://tio.run/##HU27DcIwEO2ZwgPYkn3n5OwSiQUoUkUpaVAWoIsQEkPwKahpU6RNJkkWMe@QrPO9751PfX8pZX9Yp09znMfl3ZTlvk63edyu33V6bMNzG16ltG0gtiZKssZlH62pSRR4YIGSYg7WcCAQdazUJsL4WLizuzZAdZCtyR5Dy5jAUWBAjqSs46gjkSYyzgESaUgP/p9GMLN26J45QfMaULdLOJm1n7UJTpDBwyliTVVVKJGu@wE "Jelly – Try It Online")
### How it works
```
ADṢUQµÞU  Main link (monad). Input: integer list
     µÞU  Sort by (reversed):
AD        Absolute value converted to decimal digits
  ṢUQ     Sort, reverse, take unique values
```
[Answer]
# [Julia 1.0](http://julialang.org/), ~~50~~ 47 bytes
```
x->sort(x,by=y->sort(∪([digits(-abs(y));1])))
```
[Try it online!](https://tio.run/##XY5BasMwEEX3PYWWEkggzcgZiZJcJGRhExIcQhpsF@wb5Cw9Vi/i/CldhIAY6f@Z9zWX72vfpnk9bdc57MavYbKz75bt8i9@Hz92f@zP/TTa0HajXZz7TAfn3Hof@tt0vdmT3Sdib7IUb0KN2ZsNiYoILeiUXJM3nAjGJjc6JsK4WBhRH69JGAyY9KZGFM1lgkeJITmTuoGzlkJvcMUS6BApr2v8HaVRq8bpu3JBL76xCoaCnar@ypoPCGaKgES8aZoGeQJufQI "Julia 1.0 – Try It Online")
-3 bytes by Ashlin Harris.
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), ~~7~~ 6 bytes
```
áÉ░▀zx
```
[Try it online!](https://tio.run/##y00syUjPz0n7///wwsOdj6ZNfDStoari//9oQyNjHRNzCx1dSwMTHTMjcyDTQEfX3FjHwsTSUMfY0MhAx8zEFChvbm5soWNsbhwLAA "MathGolf – Try It Online") or as a [test suite](https://tio.run/##VY5NSgNBEIX3niLM@g10/cxU98KtF3A5zCKE@AORiDEghoBbl26y9ySCuUkuMlZ3R1CGge73vq@6HubPd7fr1c00HT@P76fDx@nw9voyrS@/v3bN9XaxWG42zX7XXM3vV9unZbN/nAZigVpEm4KiZ/NjQGuCqIkgxAG9dt6bSYSYjLOhVH@E4pf@jEoGq5znh/FiIDc8QAoMj4QJTMIQZU9aUf8j@/BUrvF/42KlsyYg8okJqmD2yvfwzxtQyiA4SVR/djbUU45TgbRIVD3ny24etTE6wSL@GMiNQDBD13XoLW9ViN5@Q6qDznyg8Qc "MathGolf – Try It Online").
## Explanation
After looking at Emigna's 05AB1E solution, I found that I didn't need the absolute operator (and my previous answer was actually incorrect because of that operator). Now the main difference is that I convert to string and get unique characters instead of using the 1-byte operator in 05AB1E.
```
áÉ      Sort by the value generated from mapping each element using the next 3 instructions
  ░     Convert to string
   ▀    Get unique characters
    z   Sort reversed (last instruction of block)
     x  Reverse list (needed because I don't have a sort-reversed by mapping)
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 12 bytes
```
ñ_a ì â ñnÃw
```
[All test cases](https://ethproductions.github.io/japt/?v=1.4.6&code=8V9hIOwg4iDxbsN3&input=W1sxMjMsIDQ3OCwgLTkwNCwgNjI3NzgsIDAsIC03MywgODQ5MSwgMzEyMCwgNjQ1OCwgLTc3MzgsIDM3M10KWzExLCAtMzEyLCA5MDIsIDIzLCAzMjEsIDIxMzIsIDM0MjAyLCAtMzQsIC0zODJdCls5LCA0NCwgMjIxMiwgNCwgNiwgNiwgMSwgMiwgMTkyLCAyMSwgMjkzODQsIDBdCls0NCwgLTg4LCA5LCAyMzMsIC0zLCAxNCwgMTAxLCA3NywgNTU1LCA2N11dCi1tUg==)
Explanation:
```
ñ_        Ãw    :Sort Descending by:
  a             : Get the absolute value
    ì           : Get the digits
      â         : Remove duplicates
        ñn      : Sort the digits in descending order
```
[Answer]
# [Haskell](https://www.haskell.org/), 54 52 bytes
```
import Data.List
f=r.sortOn(r.sort.nub.show);r=reverse
```
[Try it online!](https://tio.run/##ZU7LbsIwELzzFXskkhPZXoe1VeXWI1I/AHFI1SAiIEF2Wj4/naW3Yln7mNmZ3XNfLsP1uq7j7T7nhd77pW/2Y1k2py43BdDHtP0rmun7synn@VG95S4PP0Muw3rrx4k6@po3hHfP47TQ9kQH59lQkGioTjYY2nnRxqIXMDEkZ4idB7ALrY6JMBILH6v/XhitMWsoWQR1Zg/MO0bLwStac9AQ/Ys84RBw3quDnvL8qkdMaqh14gjOvqhVWkdclnQz6w7IADoLmYihtm3hKMdq/QU "Haskell – Try It Online")
[Answer]
# [Stax](https://github.com/tomtheisen/stax), ~~6~~ 7 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
èó≥ü≤♥¥
```
[Run and debug it](https://staxlang.xyz/#p=8aa2f281f3039d&i=[%22123%22,+%22478%22,+%22-904%22,+%2262778%22,+%220%22,+%22-73%22,+%228491%22,+%223120%22,+%226458%22,+%22-7738%22,+%22373%22]&a=1&m=2)
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), 19 bytes
```
{⍵[⍒∪¨(∨'¯'~⍨⍕)¨⍵]}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/v/pR79boR72THnWsOrRC41HHCvVD69XrHvWueNQ7VfMQkNwaW/s/7VHbBGIUcj3qmwpUmqZgaGSso2BibqGjcGi9pYGJjoKZkTmIZwASMAfKWZhYGuooGBsaAUXMTEzBCs3NjYG0sbnxfwA "APL (Dyalog Extended) – Try It Online")
Fixed at a cost of +2 bytes thanks to OP.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~114~~ ~~111~~ 109 bytes
```
a;v(n){n=n<0?-n:n;for(a=0;n;n/=10)a|=1<<n%10;n=a;}c(int*a,int*b){a=v(*a)<v(*b);}f(a,n)int*a;{qsort(a,n,4,c);}
```
[Try it online!](https://tio.run/##lZTtbpswFIb/cxVHmSrZrVGN7dRQg3YhaTS5lEyWWmejtNLGuPbsHNK08CNKEkXHPh/vwxtbpE5/1vVu5907i7yPVSzl9zTeR7fZtsxX0kUXb6tMcv@vysoyXmVYqrwbahZid@0FxUfe@@qdXXteYnzkbtgwLyIfJ1z/@3XbdlQQRtTY3P1qsfPDt63/QxRADNBac@gTwA8lwY3bcXbDFqsF3xfIWIAKpIMAJdS43NwchFMFXD3BQoBfhfWHdJgR10QckuTbU7MJsYHRz3MTmefA2Gv422zxZ3B@@7lfyTXnPEnI3osPkU39dnW2WqOvPlNagLG5gLSQRsCdspRIzC12clNkAnSmsHBnljRmrcZFWz24CU594HA6xXEBhcRAcK2wpjKNqTaKqqk2FHI1I@g9oUA72FaKIGRo/BICY0FM2hc6x56cAcweQOo0R4sFPV/Tk1CJxUyi0loBy@USoRbFsyMO8R4O9za9dDwr8XXemPHD5R5vHZgPcfvWXYj90j5EEp5pUs1oamrySOsskye1F5nUM5qemjzSOsvkSe1FJs2MZqYmj7TOMnlSuzcJkJDRtune2oh/HPjW7/4D "C (gcc) – Try It Online")
Explanation:
f() uses qsort() to sort provided array in place. Using comparison function c() to compare numbers which evaluates numbers using v().
v() calculates a higher number if bigger digits are present in parameter.
[Edit 1]
Improved by 3 bytes. 2 byte credits to Kevin. Thanks
[Edit 2] 2 more bytes improved. Credits to gastropner. Thanks
[Answer]
# [J](http://jsoftware.com/), 17 bytes
```
{~[:\:~.@\:~@":@|
```
[Try it online!](https://tio.run/##PY27agNBDEX7/YqDGxMIy@ixq5kBw/6HDVOELCFNCpdJ/OsbNQ5C4iKde/V57PfLTKFTju/Htd/6Y95ybKe@/Rwv02nmvF/mM6/8dvb7NMH0/vbxxY6o4VEZrTirRsrCCKN6E0y0sPqS9wirWNi/URh5phUlM0wFFVPMNTfDPLvqk264o5p8fslKGGnpTNGsOuVJJjdqTYOaZQTiSBEiWJaFNeD4Aw "J – Try It Online")
## Explanation:
```
                @|    - find the absolute value and
             @":      - convert to string and
         @\:~         - sort down and
       ~.             - keep only the unique symbols
    \:                - grade down the entire list of strings   
  [:                  - function composition
{~                    - use the graded-down list to index into the input   
```
[Answer]
# [JavaScript (SpiderMonkey)](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/Releases/45), 68 bytes
Thanks for @Arnauld for reminding me again that SpiderMonkey uses stable sort, so -4 bytes for removing `||-1`.
```
A=>A.sort((x,y,F=n=>[...new Set(""+n)].sort().reverse())=>F(x)<F(y))
```
[Try it online!](https://tio.run/##JYxBDoIwFESv0rD6jbUBihSiJWHDBVwSFgQ/BsWWtATh9FjiavJmXubVLq3r7DDNZzcND7Qfo9@47b3aS1WU3Bk7A6xsY5XSqqg55xq/5I4zBMFJ0@ZvUG5xQesQKFVFBSu9VbBRul87o50ZkY/mCT3UUSwYSWTGyDkPE0bSWB4QepZ@yZI8YkREsS/S5HJoUgofQorG3/0A "JavaScript (SpiderMonkey) – Try It Online")
# [JavaScript (Node.js)](https://nodejs.org), 72 bytes
```
A=>A.sort((x,y,F=n=>[...new Set(""+n)].sort().reverse())=>F(x)<F(y)||-1)
```
[Try it online!](https://tio.run/##JYrRCoMgGEZfRbryZyaZbhabQTe9wC6ji2g2NkKHRivo3Z2xq4/znfPul94P7vWZU2MfOowq1KqqqbduxnglG2mUUVVLKTX6i@56xklyMtD9C6BOL9p5jQFU1eAVbg3eYN9TBuE6WOPtpOlkn3jELcs5QUIWBKVlJgi65PKALLKMphAlI4izPB4XcT4yKXkcLnkHEH4 "JavaScript (Node.js) – Try It Online")
[Answer]
# [Java (JDK)](http://jdk.java.net/), 98 bytes
```
l->l.sort((a,b)->{int r=0,i=58;for(;r==0&i-->48;)r=(b.indexOf(i)>>9)-(a.indexOf(i)>>9);return r;})
```
[Try it online!](https://tio.run/##bVLBbpwwEL3vV4xyqOwWI8AQoASkKtdWPeQY5eBlIfIWMLJNlGjFt29ndjfpqq0EHubNvDejh/fqRYn97tdRj7OxHvaYh4vXQ/i52vyD9cvUem2m/xadt50aqdQOyjn4ofR02ADMy3bQLTivPIYXo3cwYok9eKun58cnUPbZcaBWgHszuWXs7N137fzduaVpoIf6OIgGh@BMxlSw5aI56MmDraNA11lR9cayytZ19EkL0aRFxW3NtqGedt3rz55p3jQlF0z9hVS284udwFYrP1anHVD28Qn38p3zDurLZgAHiBMZQJoXAYgySgO4TXJKIsxzrBRpGQcg4wSB2zSjtjyXGGQuYQ3@yGCXwLYAyggPEpUJYkksMZVpQqiQKR1Fcs0scTzCSUJkWuD0EBXPkrTou5QF1qJrIrFEgauUNE@SMjIQjCNk5HkAWZahWP5OWs9ekKsnP05ufD17wj8suf5LMGCCdn2zVr25y3VgRODh1rx2O8bDUc1Mi@bm5ovmYWuGoWs9uz9HY13oDSkyzqvLgD5UbdvNnpH4B/rw5nw3hmbx4Yyz/TBd19cNvevxNw "Java (JDK) – Try It Online")
## Explanation
```
l->                           // Consumer<List<String>>
 l.sort(                      //  Use the incorporated sort method which uses a...
  (a,b)->{                    //   Comparator of Strings
   int r=0,                   //    define r as the result, initiated to 0
       i=58;                  //           i as the codepoint to test for.
   for(;r==0&i-->48;)         //    for each digit codepoint from '9' to '0',
                              //     and while no difference was found.
    r=                        //     set r as the difference between
     (b.indexOf(i)>>9)-       //      was the digit found in b? then 0 else -1 using the bit-shift operator
     (a.indexOf(i)>>9);       //      and was the digit found in a? then 0 else -1.
   return r;                  //    return the comparison result.
  }
 )
```
**Note:**
I needed a way to map numbers to either `0/1` or `0/-1`.
`indexOf` has the nice property that it's consistently returning `-1` for characters not found. `-1` right-shifted by any number is always `-1`. Any positive number right-shifted by a big enough number will always produce `0`.
So here we are:
```
input        input.indexOf('9')      input.indexOf('9')>>9
"999"        0                       0
"111119"     5                       0
"123456"     -1                      -1
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 55 bytes
```
->a{a.sort_by{|x|x.abs.digits.sort.reverse|[]}.reverse}
```
[Try it online!](https://tio.run/##NU1bCsIwEPz3FDlAUpLd1E0@9CIlSItV/FLaKor17HVWKYTJ7uw8hnv3Wk67xe3bd1uN12E6dK/3/JyfVduN1fFyvkzjj6@G/tEPYz835bPOn@VmTk0TiK2Jkqxx2UdrtiS6eOyCS4o5WMOBQGxjrTIRxsfCpWz@EVA4SKzJHqCBTOAoMFaOpKzjqJBodWXUgiJSoxb/ntqAWXN0zpxw86tJHS6hPmsPayLUIIOHWsSauq4RJKUsXw "Ruby – Try It Online")
[Answer]
# APL(NARS), 366 chars, 732 bytes
```
_gb←⍬
∇a _s w;t
t←_gb[a]⋄_gb[a]←_gb[w]⋄_gb[w]←t
∇
∇(_f _q)w;l;r;ls;i
(l r)←w⋄→0×⍳l≥r⋄l _s⌊2÷⍨l+r⋄ls←i←l⋄→3
  →3×⍳∼0<_gb[i]_f _gb[l]⋄ls+←1⋄ls _s i
  →2×⍳r≥i+←1
l _s ls⋄_f _q l(ls-1)⋄_f _q(ls+1)r
∇
∇r←(a qsort)w
r←¯1⋄→0×⍳1≠⍴⍴w⋄_gb←w⋄a _q 1(↑⍴w)⋄r←_gb
∇
f←{∪t[⍒t←⍎¨⍕∣⍵]}
∇r←a c b;x;y;i;m
x←f a⋄y←f b⋄r←i←0⋄m←(↑⍴x)⌊(↑⍴y)⋄→3
→0×⍳x[i]<y[i]⋄→3×⍳∼x[i]>y[i]⋄r←1⋄→0
→2×⍳m≥i+←1⋄r←(↑⍴x)>(↑⍴y)
∇
```
For the qsort operator, it is one traslation in APL of algo page 139 K&R Linguaggio C.
I think in it there is using data as C with pointers...
Test
```
 c qsort 123, 478, ¯904, 62778, 0, ¯73, 8491, 3120, 6458, ¯7738, 373 
8491 ¯904 62778 478 ¯7738 6458 ¯73 373 3120 123 0 
 c qsort 11, ¯312, 902, 23, 321, 2132, 34202, ¯34, ¯382 
902 ¯382 34202 ¯34 321 ¯312 2132 23 11 
 c qsort 9, 44, 2212, 4, 6, 6, 1, 2, 192, 21, 29384, 0 
29384 192 9 6 6 4 44 2212 21 2 1 0 
 c qsort 44, ¯88, 9, 233, ¯3, 14, 101, 77, 555, 67 
9 ¯88 67 77 555 14 44 233 ¯3 101 
```
[Answer]
# Powershell, 44 bytes
```
$args|sort{$_-split'(.)'-ne'-'|sort -u -d}-d
```
Test script:
```
$f = {
$args|sort{$_-split'(.)'-ne'-'|sort -u -d}-d
}
@(
    ,( (123, 478, -904, 62778, 0, -73, 8491, 3120, 6458, -7738, 373),
       (8491, -904, 62778, 478, -7738, 6458, 373, -73, 3120, 123, 0),
       (8491, -904, 62778, 478, -7738, 6458, -73, 373, 3120, 123, 0) )
    ,( (11, -312, 902, 23, 321, 2132, 34202, -34, -382),
       (902, -382, 34202, -34, -312, 321, 2132, 23, 11),
       (902, -382, 34202, -34, 2132, -312, 321, 23, 11) )
    ,( (9, 44, 2212, 4, 6, 6, 1, 2, 192, 21, 29384, 0),
       (29384, 192, 9, 6, 6, 4, 44, 2212, 21, 2, 1, 0),
       (29384, 192, 9, 6, 6, 44, 4, 2212, 21, 2, 1, 0),
       (29384, 192, 9, 6, 6, 44, 4, 21, 2212, 2, 1, 0) )
    ,( (44, -88, 9, 233, -3, 14, 101, 77, 555, 67),
       ,(9, -88, 67, 77, 555, 14, 44, 233, -3, 101) )
) | % {
    $a, $expected = $_
    $result = &$f @a
    $true-in($expected|%{"$result"-eq"$_"})
    "$result"
}
```
Output:
```
True
8491 -904 62778 478 -7738 6458 -73 373 3120 123 0
True
902 -382 34202 -34 2132 -312 321 23 11
True
29384 192 9 6 6 44 4 21 2212 2 1 0
True
9 -88 67 77 555 14 44 233 -3 101
```
[Answer]
# PHP, ~~87 86~~ 84 bytes
```
while(--$argc)$a[_.strrev(count_chars($n=$argv[++$i],3))]=$n;krsort($a);print_r($a);
```
Run with `-nr` or [try it online](http://sandbox.onlinephpfunctions.com/code/49f5b36a7bfa67b8f2a306b1c198753486ef2d3b).
Replace `++$i` with `$argc` (+1 byte) to suppress the Notice (and render `-n` obosolete).
**breakdown**
```
while(--$argc)  # loop through command line arguments
    $a[                             # key=
        _.                              # 3. prepend non-numeric char for non-numeric sort
        strrev(                         # 2. reverse =^= sort descending
        count_chars($n=$argv[++$i],3)   # 1. get characters used in argument
        )
    ]=$n;                           # value=argument
krsort($a);     # sort by key descending
print_r($a);    # print
```
`-` is "smaller" than the digits, so it has no affect on the sorting.
[Answer]
# Common Lisp, 88 bytes
```
(sort(read)'string> :key(lambda(x)(sort(remove-duplicates(format()"~d"(abs x)))'char>)))
```
[Try it online!](https://tio.run/##NcpBDsIgEEDRq0y66cyiiQhIddG7TAG1ESwBNHXj1bEbdz8v34alpIYpL88KDcuaK2bPjvpSd7tNcHn4DwaOs2Pc6H/E9e0H90phsVx9weuaI1ek7us65LnARkS9vXOe9mjUUCkYxhHOcJQSBglCgTgIMAa01nAy9AM)
Good old verbose Common Lisp!
Explanation:
```
(sort                   ; sort
 (read)                 ; what to sort: a list of numbers, read on input stream 
 'string>               ; comparison predicate (remember: this is a typed language!)
 :key (lambda (x)       ; how to get an element to sort; get a number
       (sort (remove-duplicates  ; then sort the unique digits (characters) 
               (format() "~d" (abs x))) ; from its string representation
             'char>)))  ; with the appropriate comparison operator for characters
```
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), ~~75~~ 74 bytes
-1 thanks @ASCII-only
```
x=>x.OrderByDescending(y=>String.Concat((y+"").Distinct().OrderBy(z=>-z)))
```
[Try it online!](https://tio.run/##rZBRS8MwEMff@ylCnxJMS5ukS8PWPugUFGEPPvggPswsk8BMoc1wnfjZ653oi4ggDMLl7n@X@93FDpkd/HS1D3ZxfRn2L65fP@3cwofY8p9CS7akmQ5Ne8hX/cb15@PSDdaFjQ/PdGzau9iDl190wa4jpeNZmrJ86Yfog42UfT@ix6bNjoyxaZ4kUDx0O5ff9z66Wx8c/epy0/lAU5JysqXBvT48krekFJITpWtOMlMoTmZCY1BArCFTK1NyIksBwkxVWKa1hEtqmbwDcP4Ljv17CGBkAOHEFGBwJClAE6WEUCqBaiYVmlqcjmtgdWgqBKJx@c@DYLAGJ0HfyBpyxemwyMxq@ESDu0rcCngglgXwtOakqioYRf@BnD4A "C# (Visual C# Interactive Compiler) – Try It Online")
In C#, strings are considered "enumerables" of characters. I use this to my advantage by first converting each number to a string. LINQ is then leveraged to get the unique characters (digits) sorted in reverse order. I convert each sorted character array back into a string and use that as the sort key to order the whole list.
[Answer]
# [Husk](https://github.com/barbuz/Husk), 7 bytes
```
↔Öö↔Oda
```
[Try it online!](https://tio.run/##yygtzv7//1HblMPTDm8DUv4pif///482NDLWMTG30NG1NDDRMTMyBzINdHTNjXUsTCwNdYwNjQx0zExMgfLm5sYWOsbmxrEA "Husk – Try It Online")
[Answer]
# [Vyxal 3](https://github.com/Vyxal/Vyxal/tree/version-3), 6 bytes
```
µᵛfG]Ṛ
```
[Try it Online!](https://vyxal.github.io/latest.html#WyIiLCIiLCLCteG1m2ZHXeG5miIsIiIsIlsxMjMsIDQ3OCwgLTkwNCwgNjI3NzgsIDAsIC03MywgODQ5MSwgMzEyMCwgNjQ1OCwgLTc3MzgsIDM3M10iLCIzLjQuMSJd)
need two bytes to reverse the end result otherwise i might have a 4 byter lol
[Answer]
# [Perl 5](https://www.perl.org/) `-nl`, 68 bytes
```
$a{eval"9876543210=~y/$_//dcr"}=$_}{say$a{$_}for reverse sort keys%a
```
[Try it online!](https://tio.run/##DcrRCoMgFIDh@/MUEu3SpR7t2EWPsGcI2RyMSYZGEFGPPufdB/@/@BRMKa07/OZCM1jqjUYlxXjtXTt13euZmnNsp/PIbq9b1TsmlvzmU/Ysx7Syr9/zzZUiFYImC3wQGnpFlQI4IVg9SECpBPTa1E6EFpDwF5f1E@dc@MPchRSFh/kP "Perl 5 – Try It Online")
]