Défi:

Étant donné une liste d'entiers, trier par ordre décroissant par leur seul chiffre le plus grand. L'ordre des nombres avec le même plus grand chiffre est ensuite trié par deuxième plus grand chiffre, etc.
Nous ignorons les chiffres dupliqués dans les nombres. Et si tous les chiffres d'un numéro sont identiques, l'ordre de ces numéros dans la liste peut être comme vous le souhaitez.

Exemple:

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]

Pourquoi? Voici les chiffres pertinents sur lesquels les numéros ont été triés:

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

Règles du défi:

• Nous ignorons les chiffres en double, donc 478et -7738seront classés comme 478, -7738, car les plus gros chiffres sont [8,7,4]et [8,7,3], et non [8,7,4]et [8,7,7,3].
• Si plusieurs numéros ont les mêmes chiffres, l'ordre de ceux-ci peut être dans les deux sens. Donc, 373et -73peut être trié comme les deux 373, -73ou -73, 373(les chiffres correspondent [7,3]à ces deux nombres).
• Si un numéro ne contient plus de chiffres à vérifier, il sera placé à l'arrière des numéros concernés. Donc, 123et 3120sera trié comme 3120, 123, car les plus gros chiffres [3,2,1]sont les mêmes, mais 0vient avant none.
• Vous pouvez supposer que tous les nombres en entrée sont dans la plage [-999999,999999].
• Une seule des sorties possibles suffit en conséquence, mais vous êtes autorisé à sortir toutes les sorties possibles où les sous-listes peuvent être dans n'importe quelle permutation si vous le souhaitez (bien que je doute que cela économiserait des octets dans n'importe quelle langue).

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse avec des règles d'E / S par défaut , vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code (par exemple TIO ).
• De plus, l'ajout d'une explication à votre réponse est fortement recommandé.

Cas de test:

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 octets

ΣêR}R

Essayez-le en ligne! ou comme suite de tests

Explication

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

R , 97 95 octets

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

Essayez-le en ligne!

Ce défi semble avoir été pessimisé pour R. Explication de la version originale (commencer à 1. et remonter):

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 octets

-1 octet grâce à Jo King
-2 octets grâce à Phil H

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

Essayez-le en ligne!

Explication

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

-1 octet merci à Jonas Ausevicius .

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

Essayez-le en ligne!

Non 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

Essayez-le en ligne!

Python 2 , 58 60 octets

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

Essayez-le en ligne!

Brachylog , 9 octets

{ȧdṫo₁}ᵒ¹

Remarque: en raison du fonctionnement de la commande dans brachylog, cela ne fonctionne pas correctement sur le numéro. Ce problème est résolu en convertissant le nombre en chaîne ( ṫ) au prix d'un octet.

Essayez-le en ligne!

Pyth, 7 6 octets

-1 octet par @Sok

_o_{S`

Pyth, qui utilise uniquement ASCII imprimable, est un peu désavantagé ici. Encodé de manière optimale, ce serait des 6*log(95)/log(256) = 4.927octets, battant 05AB1E.

Expliqué:

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

Essayez-le ici .

Gelée , 8 octets

ADṢUQµÞU

Essayez-le en ligne!

Comment ça marche

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 octets

áÉ░▀zx

Essayez-le en ligne! ou comme suite de tests .

Explication

Après avoir regardé la solution 05AB1E d'Emigna, j'ai constaté que je n'avais pas besoin de l'opérateur absolu (et ma réponse précédente était en fait incorrecte à cause de cet opérateur). Maintenant, la principale différence est que je convertis en chaîne et obtient des caractères uniques au lieu d'utiliser l'opérateur à 1 octet dans 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 octets

ñ_a ì â ñnÃw

Tous les cas de test

Explication:

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

Haskell , 54 52 octets

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

Essayez-le en ligne!

Stax , 6 7 octets

èó≥ü≤♥¥

Exécuter et déboguer

APL (Dyalog Extended) , 19 octets

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

Essayez-le en ligne!

Fixé à un coût de +2 octets grâce à OP.

C (gcc) , 114 111 109 octets

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

Essayez-le en ligne!

Explication:

f () utilise qsort () pour trier le tableau fourni en place. Utiliser la fonction de comparaison c () pour comparer les nombres qui évalue les nombres en utilisant v (). v () calcule un nombre plus élevé si des chiffres plus grands sont présents dans le paramètre.

[Edit 1] Amélioré de 3 octets. Crédits de 2 octets à Kevin. Merci

[Edit 2] 2 octets supplémentaires améliorés. Crédits à gastropner. Merci

J , 17 octets

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

Essayez-le en ligne!

Explication:

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

Merci pour @Arnauld de me rappeler à nouveau que SpiderMonkey utilise un tri stable, donc -4 octets pour la suppression ||-1.

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

Essayez-le en ligne!

JavaScript (Node.js) , 72 octets

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

Essayez-le en ligne!

Java (JDK) , 98 octets

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

Essayez-le en ligne!

Explication

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

Remarque:

J'avais besoin d'un moyen de mapper des nombres sur 0/1ou 0/-1.

indexOfa la belle propriété qu'il revient constamment -1pour les caractères non trouvés. -1décalé vers la droite par un nombre est toujours -1. Tout nombre positif décalé vers la droite d'un nombre suffisamment grand produira toujours 0.

Donc nous en sommes là:

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

Ruby , 55 octets

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

Essayez-le en ligne!

Perl 5 -nl , 68 octets

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

Essayez-le en ligne!

Julia 1.0 , 50 octets

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

Essayez-le en ligne!

APL (NARS), 366 caractères, 732 octets

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

Pour l'opérateur qsort, c'est une traduction en APL d'algo page 139 K&R Linguaggio C. Je pense qu'il y utilise des données comme C avec des pointeurs ... 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 

Powershell, 44 octets

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

Script de test:

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

Sortie:

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 octets

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

Courez avec -nrou essayez-le en ligne .

Remplacez ++$ipar $argc(+1 octet) pour supprimer l'avis (et le rendre -nobsolète).

panne

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

- est "plus petit" que les chiffres, il n'a donc aucun effet sur le tri.

Lisp commun, 88 octets

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

Essayez-le en ligne!

Bon vieux Lisp commun bavard!

Explication:

(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 octets

-1 merci @ ASCII uniquement

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

Essayez-le en ligne!

En C #, les chaînes sont considérées comme des "énumérables" de caractères. J'utilise cela à mon avantage en convertissant d'abord chaque numéro en une chaîne. LINQ est ensuite exploité pour obtenir les caractères uniques (chiffres) triés dans l'ordre inverse. Je reconvertis chaque tableau de caractères trié en une chaîne et l'utilise comme clé de tri pour ordonner la liste entière.