Reto:

Dada una lista de enteros, ordene descendiendo por sus dígitos más grandes. El orden de los números con el mismo dígito más grande se ordena por el segundo dígito más grande, etc.
Ignoramos los dígitos duplicados en los números. Y si todos los dígitos de un número son iguales, el orden de esos números en la lista puede ser de la forma que desee.

Ejemplo:

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é? Estos son los dígitos relevantes en los que se ordenaron los números:

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

Reglas de desafío:

• Ignoramos dígitos duplicados, así 478y -7738se ordenan como 478, -7738, debido a que las cifras son más grandes [8,7,4]y [8,7,3], y no [8,7,4]e [8,7,7,3].
• Si varios números tienen los mismos dígitos, el orden de esos puede ser de cualquier manera. Entonces, 373y -73se puede ordenar como ambos 373, -73o -73, 373(los dígitos son [7,3]para ambos números).
• Si un número no contiene más dígitos para verificar, se colocará en la parte posterior de los números relevantes. Entonces, 123y 3120se ordenará como 3120, 123, porque los dígitos más grandes [3,2,1]son los mismos, pero 0vienen antes none.
• Puede suponer que todos los números en la entrada están en el rango [-999999,999999].
• Como resultado, solo una de las salidas posibles es suficiente, pero puede emitir todas las salidas posibles donde las sublistas pueden estar en cualquier permutación si lo desea (aunque dudo que ahorre bytes en cualquier idioma).

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de code-golf lo desanimen a publicar respuestas con lenguajes que no sean codegolfing. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Las reglas estándar se aplican a su respuesta con las reglas de E / S predeterminadas , por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código (es decir, TIO ).
• Además, se recomienda agregar una explicación para su respuesta.

Casos de prueba:

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

Pruébalo en línea! o como un conjunto de pruebas

Explicación

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

R , 97 95 bytes

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

Pruébalo en línea!

Este desafío parece haber sido pesimizado para R. Explicación de la versión original (comienza en 1. y continúa):

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 gracias a Jo King
-2 bytes gracias a Phil H

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

Pruébalo en línea!

Explicación

       {                      }  # 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 gracias a Jonas Ausevicius .

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

Pruébalo en línea!

Sin golf

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

Pruébalo en línea!

Python 2 , 58 60 bytes

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

Pruébalo en línea!

Brachylog , 9 bytes

{ȧdṫo₁}ᵒ¹

Nota: debido a cómo funciona el pedido en brachylog, no funciona en número correctamente. Esto se soluciona enviando el número a una cadena ( ṫ) al costo de 1 byte.

Pruébalo en línea!

Pyth, 7 6 bytes

-1 byte por @Sok

_o_{S`

Pyth, que usa solo ASCII imprimible, tiene algunas desventajas aquí. Esta codificación óptima sería 6*log(95)/log(256) = 4.927bytes, superando a 05AB1E.

Explicado:

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

Probarlo aquí .

Jalea , 8 bytes

ADṢUQµÞU

Pruébalo en línea!

Cómo 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

Pruébalo en línea! o como un conjunto de pruebas .

Explicación

Después de mirar la solución 05AB1E de Emigna, descubrí que no necesitaba el operador absoluto (y mi respuesta anterior era realmente incorrecta debido a ese operador). Ahora la diferencia principal es que convierto a cadena y obtengo caracteres únicos en lugar de usar el operador de 1 byte en 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)

Japt , 12 bytes

ñ_a ì â ñnÃw

Todos los casos de prueba

Explicación:

ñ_        Ã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

Pruébalo en línea!

Stax , 6 7 bytes

èó≥ü≤♥¥

Ejecutar y depurarlo

APL (Dyalog Extended) , 19 bytes

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

Pruébalo en línea!

Corregido a un costo de +2 bytes gracias a 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);}

Pruébalo en línea!

Explicación:

f () usa qsort () para ordenar la matriz proporcionada en su lugar. Usando la función de comparación c () para comparar números que evalúa los números usando v (). v () calcula un número más alto si hay dígitos más grandes en el parámetro.

[Editar 1] Mejorado en 3 bytes. Créditos de 2 bytes a Kevin. Gracias

[Editar 2] 2 bytes más mejorados. Créditos a gastropner. Gracias

J , 17 bytes

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

Pruébalo en línea!

Explicación:

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

Gracias por @Arnauld por recordarme nuevamente que SpiderMonkey usa una ordenación estable, por lo que -4 bytes para eliminar ||-1.

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

Pruébalo en línea!

JavaScript (Node.js) , 72 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

Explicación

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:

Necesitaba una forma de asignar números a cualquiera 0/1o 0/-1.

indexOftiene la buena propiedad de que constantemente devuelve -1caracteres que no se encuentran. -1desplazado a la derecha por cualquier número es siempre -1. Cualquier número positivo desplazado a la derecha por un número suficientemente grande siempre producirá 0.

Aqui estamos:

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}

Pruébalo en línea!

Perl 5 -nl , 68 bytes

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

Pruébalo en línea!

Julia 1.0 , 50 bytes

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

Pruébalo en línea!

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 el operador qsort, es una traducción en APL de algo página 139 K&R Linguaggio C. Creo que en él se usan datos como C con punteros ... Prueba

 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 prueba:

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

Salida:

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

Ejecutar -nro probarlo en línea .

Reemplace ++$icon $argc(+1 byte) para suprimir el Aviso (y hacer -nobosolete).

Descompostura

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

- es "más pequeño" que los dígitos, por lo que no tiene ningún efecto en la clasificación.

Lisp común, 88 bytes

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

Pruébalo en línea!

Buena vieja verbosa Common Lisp!

Explicación:

(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 interactivo de Visual C #) , 75 74 bytes

-1 gracias @ solo ASCII

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

Pruébalo en línea!

En C #, las cadenas se consideran "enumerables" de caracteres. Utilizo esto para mi ventaja al convertir primero cada número en una cadena. LINQ se aprovecha para obtener los caracteres únicos (dígitos) ordenados en orden inverso. Convierto cada conjunto de caracteres ordenados nuevamente en una cadena y lo uso como la clave de clasificación para ordenar la lista completa.