挑战：

给定一个整数列表，请按其最大的一位数字降序排列。具有相同大数字的数字的顺序将按第二大数字排序，依此类推。
我们忽略数字中重复的数字。而且，如果一个数字中的所有数字都相同，则列表中这些数字的顺序可以是您想要的任何方式。

例：

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]

为什么？以下是对数字进行排序的相关数字：

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]]

挑战规则：

• 我们忽略重复的数字，所以478和-7738将按排序478, -7738，因为最大的数字是[8,7,4]和[8,7,3]，而不是[8,7,4]和[8,7,7,3]。
• 如果多个数字具有相同的数字，则它们的顺序可以是任一种方式。因此，373并且-73可以按373, -73或排序-73, 373（[7,3]这些数字都是数字）。
• 如果一个数字不再包含要检查的数字，它将被放置在相关数字的后面。因此，123并且3120将被排序为3120, 123，因为最大的数字[3,2,1]相同，但是位于0之前none。
• 您可以假设输入中的所有数字都在范围内[-999999,999999]。
• 结果可能只是其中一个输出就足够了，但是您可以根据需要输出所有可能的输出，其中子列表可以任意排列（尽管我怀疑它会以任何语言保存字节）。

一般规则：

• 这是代码高尔夫球，因此最短答案以字节为单位。
  不要让代码高尔夫球语言阻止您发布使用非代码高尔夫球语言的答案。尝试针对“任何”编程语言提出尽可能简短的答案。
• 标准规则适用于具有默认I / O规则的答案，因此允许您使用STDIN / STDOUT，具有适当参数的函数/方法以及返回类型的完整程序。你的来电。
• 默认漏洞是禁止的。
• 如果可能的话，请添加一个带有测试代码的链接（即TIO）。
• 另外，强烈建议为您的答案添加说明。

测试用例：

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]

05AB1E，5个字节

ΣêR}R

在线尝试！ 或作为测试套件

说明

Σ  }    # sort input by
 ê      # its sorted unique characters
  R     # reversed (to sort descending)
    R   # reverse the result (to sort descending)

R，97 95字节

function(x)x[rev(order(sapply(Map(sort,Map(unique,strsplit(paste(x),"")),T),Reduce,f=paste0)))]

在线尝试！

R似乎对这个挑战感到悲观。原始版本的解释（从1.开始并逐步完善）：

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
              )
        )
    ]
}

Perl 6的，36 34 33 31个字节

-1字节感谢Jo King
--2字节感谢Phil H

*.sort:{sort 1,|set -<<m:g/\d/}

在线尝试！

说明

       {                      }  # 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

Python 2中，60 55 54字节

-1个字节，感谢Jonas Ausevicius。

def f(l):l.sort(cmp,lambda n:sorted(set(`n`))[::-1],1)

在线尝试！

不打高尔夫球

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

在线尝试！

Python 2中，58 60个字节

lambda a:sorted(a,key=lambda x:sorted(set(`x`))[::-1])[::-1]

在线尝试！

Brachylog，9个字节

{ȧdṫo₁}ᵒ¹

注意：由于排序在brachylog中的工作方式，因此无法正确处理数字。通过将数字强制转换为字符串来解决此问题（ṫ）来解决此问题，代价是1个字节。

在线尝试！

Pyth，7个 6字节

-1字节@Sok

_o_{S`

仅使用可打印ASCII的Pyth在这里有点不利。最佳编码为6*log(95)/log(256) = 4.927字节，击败05AB1E。

解释：

 o              Sort the implicit input by lambda N:
  _               reversed
   {               uniquified
    S               sorted
     '               string representation [of N]
_               then reverse the result.

在这里尝试。

果冻，8字节

ADṢUQµÞU

在线尝试！

怎么运行的

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

MathGolf，7 6个字节

áÉ░▀zx

在线尝试！或作为测试套件。

说明

在查看Emigna的05AB1E解决方案之后，我发现我不需要绝对运算符（由于该运算符，我先前的回答实际上是错误的）。现在的主要区别是，我将转换为字符串并获得唯一字符，而不是在05AB1E中使用1字节运算符。

áÉ      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)

Japt，12个字节

ñ_a ì â ñnÃw

所有测试用例

说明：

ñ_        Ãw    :Sort Descending by:
  a             : Get the absolute value
    ì           : Get the digits
      â         : Remove duplicates
        ñn      : Sort the digits in descending order

Haskell，54 52字节

import Data.List
f=r.sortOn(r.sort.nub.show);r=reverse

在线尝试！

Stax，6个 7 字节

èó≥ü≤♥¥

运行并调试

APL（Dyalog扩展），19字节

{⍵[⍒∪¨(∨'¯'~⍨⍕)¨⍵]}

在线尝试！

由于OP，固定为+2个字节。

C（gcc），114个 111 109字节

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);}

在线尝试！

说明：

f（）使用qsort（）对提供的数组进行排序。使用比较函数c（）比较数字，然后使用v（）计算数字。如果参数中存在较大的数字，则v（）将计算一个较大的数字。

[编辑1]改进了3个字节。2个字节的信用给Kevin。谢谢

[编辑2]改进了2个字节。归功于gastropner。谢谢

J，17个字节

{~[:\:~.@\:~@":@|

在线尝试！

说明：

                @|    - 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   

JavaScript（SpiderMonkey），68字节

感谢@Arnauld再次提醒我SpiderMonkey使用稳定排序，因此-4个字节用于删除||-1。

A=>A.sort((x,y,F=n=>[...new Set(""+n)].sort().reverse())=>F(x)<F(y))

在线尝试！

JavaScript（Node.js），72字节

A=>A.sort((x,y,F=n=>[...new Set(""+n)].sort().reverse())=>F(x)<F(y)||-1)

在线尝试！

Java（JDK），98字节

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;})

在线尝试！

说明

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.
  }
 )

注意：

我需要一种将数字映射到0/1或的方法0/-1。

indexOf具有不错的属性，它-1对于未找到的字符始终返回。-1总是右移任何数字-1。向右偏移足够大的任何正数将始终产生0。

所以我们在这里：

input        input.indexOf('9')      input.indexOf('9')>>9
"999"        0                       0
"111119"     5                       0
"123456"     -1                      -1

Ruby，55个字节

->a{a.sort_by{|x|x.abs.digits.sort.reverse|[]}.reverse}

在线尝试！

Perl -nl 5、68个字节

$a{eval"9876543210=~y/$_//dcr"}=$_}{say$a{$_}for reverse sort keys%a

在线尝试！

朱莉娅1.0，50字节

x->sort(x,by=y->sort(unique([digits(-abs(y));1])))

在线尝试！

APL（NARS），366个字符，732个字节

_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)
∇

对于qsort运算符，这是算法页面139 K＆R Linguaggio C的APL中的一种转换。我认为其中使用指针将数据用作C。

 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 

Powershell，44个字节

$args|sort{$_-split'(.)'-ne'-'|sort -u -d}-d

测试脚本：

$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"
}

输出：

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

PHP，87 86 84字节

while(--$argc)$a[_.strrev(count_chars($n=$argv[++$i],3))]=$n;krsort($a);print_r($a);

用-nr或运行在线尝试。

替换++$i为$argc（+1字节）以禁止显示该通知（并使其-n过时）。

分解

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

- 比数字“小”，因此对排序没有影响。

通用Lisp，88个字节

(sort(read)'string> :key(lambda(x)(sort(remove-duplicates(format()"~d"(abs x)))'char>)))

在线尝试！

好老冗长的Common Lisp！

说明：

(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

C＃（Visual C＃交互式编译器），75 74字节

-1感谢@ ASCII-only

x=>x.OrderByDescending(y=>String.Concat((y+"").Distinct().OrderBy(z=>-z)))

在线尝试！

在C＃中，字符串被视为字符的“可枚举”。首先将每个数字转换为字符串，以此来发挥我的优势。然后利用LINQ获得以相反顺序排序的唯一字符（数字）。我将每个排序的字符数组都转换回字符串，然后将其用作排序键来对整个列表进行排序。