チャレンジ：

整数のリストが与えられたら、それらの単一の最大桁で降順でソートします。次に、同じ最大桁の数字の順序は、2番目に大きい桁などでソートさ
れます。数字の重複桁は無視されます。また、数字のすべての数字が同じ場合、リスト内の数字の順序は任意に設定できます。

例：

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]。
• 結果として可能な出力の1つだけで十分ですが、必要に応じて、サブリストが任意の順列にある可能性のあるすべての出力を出力できます（どの言語でもバイトを節約できるとは思いませんが）。

一般的なルール：

• これはcode-golfであるため、バイト単位の最短回答が優先されます。
  コードゴルフ言語では、非コードゴルフ言語で回答を投稿することを妨げないでください。「任意の」プログラミング言語の可能な限り短い答えを考えてみてください。
• デフォルトの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バイト

Jo Kingのおかげで-1バイト
Phil Hのおかげで2バイト

*.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

パイソン2、60の 55 54バイト

Jonas Auseviciusのおかげで-1バイト。

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バイト

@Sokによる -1バイト

_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

オンラインでお試しください！

スタックス、6 7 バイト

èó≥ü≤♥¥

実行してデバッグする

APL（Dyalog Extended）、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バイト改善。Kevinへの2バイトのクレジット。ありがとう

[編集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バイト

SpiderMonkeyが安定したソートを使用していることを思い出させてくれた@Arnauldに感謝します||-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 5、68 -nlバイト

$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での翻訳の1つです。ポインターを使用して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またはで実行、オンラインで試してください。

（+1バイト）に置き換え++$iて$argc、通知を抑制します（およびレンダリングします）-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

- は数字よりも「小さい」ため、ソートには影響しません。

Common 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＃Interactive Compiler）、75 74バイト

-1ありがとう@ASCIIのみ

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

オンラインでお試しください！

C＃では、文字列は文字の「列挙可能」と見なされます。最初に各数値を文字列に変換することで、これを活用しています。次に、LINQを利用して、一意の文字（数字）を逆順に並べ替えます。ソートされた各文字配列を文字列に変換し直し、それをソートキーとして使用してリスト全体を並べ替えます。