Desafio:

Dada uma lista de números inteiros, classifique decrescente pelo (s) maior (s) dígito (s). A ordem dos números com o mesmo dígito maior é classificada pelo segundo maior dígito, etc.
Ignoramos dígitos duplicados nos números. E se todos os dígitos de um número forem iguais, a ordem desses números na lista poderá ser da maneira que você desejar.

Exemplo:

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]

Por quê? Aqui estão os dígitos relevantes em que os números foram classificados:

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

Regras do desafio:

• Ignoramos dígitos duplicados, portanto, 478e -7738serão ordenados como 478, -7738, porque os dígitos maiores são [8,7,4]e [8,7,3], e não [8,7,4]e [8,7,7,3].
• Se vários números tiverem os mesmos dígitos, a ordem deles poderá ser de qualquer maneira. Portanto, 373e -73pode ser classificado como ambos 373, -73ou -73, 373(os dígitos são [7,3]para esses dois números).
• Se um número não contiver mais dígitos a serem verificados, será colocado na parte de trás dos números relevantes. Portanto, 123e 3120será classificado como 3120, 123, porque os dígitos maiores [3,2,1]são os mesmos, mas 0vêm antes none.
• Você pode assumir que todos os números na entrada estão no intervalo [-999999,999999].
• Apenas uma das saídas possíveis é suficiente como resultado, mas você pode gerar todas as saídas possíveis, onde as sublistas podem estar em qualquer permutação, se você quiser (embora eu duvide que isso salvaria bytes em qualquer idioma).

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta com as regras de E / S padrão , para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código (ou seja, TIO ).
• Além disso, é altamente recomendável adicionar uma explicação para sua resposta.

Casos de teste:

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 bytes

ΣêR}R

Experimente online! ou como um conjunto de testes

Explicação

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

R , 97 bytes 95

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

Experimente online!

Este desafio parece ter sido pessimizado para R. Explicação da versão original (inicie em 1. e prossiga):

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 bytes

-1 byte graças a Jo King
-2 bytes graças a Phil H

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

Experimente online!

Explicação

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

-1 byte graças a Jonas Ausevicius .

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

Experimente 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

Experimente online!

Python 2 , 58 60 bytes

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

Experimente online!

Braquilog , 9 bytes

{ȧdṫo₁}ᵒ¹

Nota: devido ao modo como a ordem funciona no braquilog, ela não funciona no número corretamente. Isso é corrigido lançando o número em uma sequência (ṫ ) ao custo de 1 byte.

Experimente online!

Pitão, 7 6 bytes

-1 byte por @Sok

_o_{S`

O Pyth, que usa apenas ASCII imprimível, é uma desvantagem aqui. Idealmente codificado, isso seria6*log(95)/log(256) = 4.927 bytes, superando 05AB1E.

Explicado:

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

Experimente aqui .

Geléia , 8 bytes

ADṢUQµÞU

Experimente online!

Como funciona

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 bytes

áÉ░▀zx

Experimente online! ou como uma suíte de teste .

Explicação

Depois de analisar a solução 05AB1E da Emigna, descobri que não precisava do operador absoluto (e minha resposta anterior estava realmente incorreta por causa desse operador). Agora, a principal diferença é que eu converto em string e obtenho caracteres únicos em vez de usar o operador de 1 byte em 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)

Japonês , 12 bytes

ñ_a ì â ñnÃw

Todos os casos de teste

Explicação:

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

Haskell , 54 52 bytes

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

Experimente online!

Stax , 6 7 bytes

èó≥ü≤♥¥

Execute e depure

APL (Dyalog Extended) , 19 bytes

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

Experimente online!

Corrigido com um custo de +2 bytes, graças ao OP.

C (gcc) , 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);}

Experimente online!

Explicação:

f () usa qsort () para classificar a matriz fornecida no local. Usando a função de comparação c () para comparar números que avalia números usando v (). v () calcula um número maior se dígitos maiores estiverem presentes no parâmetro

[Editar 1] Melhorado por 3 bytes. 2 créditos de bytes para Kevin. obrigado

[Edit 2] Mais 2 bytes melhorados. Créditos ao gastropner. obrigado

J , 17 bytes

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

Experimente online!

Explicação:

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

Obrigado por @Arnauld por me lembrar novamente que o SpiderMonkey usa classificação estável, portanto -4 bytes para remover ||-1 .

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

Experimente online!

JavaScript (Node.js) , 72 bytes

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

Experimente online!

Java (JDK) , 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;})

Experimente online!

Explicação

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

Nota:

Eu precisava de uma maneira de mapear números para um 0/1ou outro 0/-1.

indexOftem a propriedade legal de retornar consistentemente -1caracteres não encontrados. -1Shift à direita por qualquer número é sempre -1. Qualquer número positivo deslocado para a direita por um número grande o suficiente sempre produzirá0 .

Então aqui estamos nós:

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

Ruby , 55 bytes

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

Experimente online!

Perl 5 -nl , 68 bytes

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

Experimente online!

Julia 1.0 , 50 bytes

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

Experimente online!

APL (NARS), 366 caracteres, 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)
∇

Para o operador qsort, é uma tradução no APL de algo na página 139 K&R Linguaggio C. Acho que nele existem dados como C com ponteiros ... Teste

 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 bytes

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

Script de teste:

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

Saída:

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 bytes

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

Corra com -nrou experimente online .

Substitua ++$ipor $argc(+1 byte) para suprimir o Aviso (e tornar -nobsoleto).

demolir

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

- é "menor" que os dígitos, portanto não afeta a classificação.

Lisp comum, 88 bytes

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

Experimente online!

Bom e velho verboso Common Lisp!

Explicação:

(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 # (compilador interativo do Visual C #) , 75 74 bytes

-1 obrigado @ somente ASCII

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

Experimente online!

Em C #, cadeias de caracteres são consideradas "enumeráveis" de caracteres. Eu uso isso para minha vantagem, primeiro convertendo cada número em uma string. O LINQ é então alavancado para obter os caracteres únicos (dígitos) classificados na ordem inversa. Eu converto cada matriz de caracteres classificados novamente em uma string e a uso como a chave de classificação para ordenar a lista inteira.