Herausforderung:

Sortieren Sie bei einer Liste mit Ganzzahlen absteigend nach den größten einzelnen Ziffern. Die Reihenfolge für Zahlen mit der gleichen größten Ziffer wird dann nach der zweitgrößten Ziffer usw. sortiert.
Doppelte Ziffern in Zahlen werden ignoriert. Und wenn alle Ziffern einer Nummer gleich sind, kann die Reihenfolge dieser Nummern in der Liste beliebig sein.

Beispiel:

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]

Warum? Hier sind die relevanten Ziffern, nach denen die Nummern sortiert wurden:

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

Herausforderungsregeln:

• Wir ignorieren doppelte Ziffern 478und -7738werden als geordnet 478, -7738, da die größten Ziffern [8,7,4]und [8,7,3]und nicht [8,7,4]und sind [8,7,7,3].
• Wenn mehrere Nummern die gleichen Ziffern haben, kann die Reihenfolge dieser so oder so sein. So 373und -73kann als beide 373, -73oder sortiert werden -73, 373(Ziffern sind [7,3]für beide dieser Nummern).
• Wenn eine Nummer keine weiteren zu überprüfenden Ziffern enthält, wird sie hinter den entsprechenden Nummern platziert. Also 123und 3120wird sortiert wie 3120, 123, da die größten Ziffern gleich [3,2,1]sind, aber 0vorher kommen none.
• Sie können davon ausgehen, dass alle Zahlen in der Eingabe im Bereich liegen [-999999,999999].
• Nur eine der möglichen Ausgaben ist als Ergebnis ausreichend, aber Sie können alle möglichen Ausgaben ausgeben, bei denen sich Unterlisten in einer beliebigen Permutation befinden können, wenn Sie dies wünschen (obwohl ich bezweifle, dass dadurch Bytes in einer beliebigen Sprache gespart werden).

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln mit Standard-E / A-Regeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp, verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu (z. B. TIO ).
• Außerdem wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

Testfälle:

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

Probieren Sie es online! oder als Testsuite

Erläuterung

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

Probieren Sie es online!

Diese Herausforderung scheint für R pessimisiert worden zu sein. Erläuterung der Originalversion (Beginn um 1. und Aufarbeitung):

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 dank Jo King
-2 Byte dank Phil H.

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

Probieren Sie es online!

Erläuterung

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

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

Probieren Sie es 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

Probieren Sie es online!

Python 2 , 58 60 Bytes

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

Probieren Sie es online!

Brachylog , 9 Bytes

{ȧdṫo₁}ᵒ¹

Hinweis: Aufgrund der Funktionsweise der Bestellung in Brachylog funktioniert die Bestellung bei Nummern nicht richtig. Dies wird behoben, indem die Zahl auf ṫKosten von 1 Byte in eine Zeichenfolge ( ) umgewandelt wird.

Probieren Sie es online!

Pyth, 7 6 Bytes

-1 Byte von @Sok

_o_{S`

Pyth, das nur druckbares ASCII verwendet, ist hier etwas nachteilig. Optimal codiert wären dies 6*log(95)/log(256) = 4.927Bytes vor 05AB1E.

Erklärt:

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

Probieren Sie es hier aus .

Gelee , 8 Bytes

ADṢUQµÞU

Probieren Sie es online!

Wie es funktioniert

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

Probieren Sie es online! oder als Testsuite .

Erläuterung

Als ich mir die 05AB1E-Lösung von Emigna ansah, stellte ich fest, dass ich keinen absoluten Operator benötigte (und meine vorherige Antwort war aufgrund dieses Operators tatsächlich falsch). Der Hauptunterschied besteht nun darin, dass ich in einen String konvertiere und eindeutige Zeichen erhalte, anstatt den 1-Byte-Operator in 05AB1E zu verwenden.

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

Alle Testfälle

Erläuterung:

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

Probieren Sie es online!

Stax , 6 7 Bytes

èó≥ü≤♥¥

Führen Sie es aus und debuggen Sie es

APL (Dyalog Extended) , 19 Byte

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

Probieren Sie es online!

Bei einem Aufwand von +2 Bytes dank OP behoben.

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

Probieren Sie es online!

Erläuterung:

f () verwendet qsort (), um das angegebene Array an Ort und Stelle zu sortieren. Verwenden der Vergleichsfunktion c () zum Vergleichen von Zahlen, die Zahlen mit v () auswerten. v () berechnet eine höhere Zahl, wenn der Parameter größere Ziffern enthält.

[Edit 1] Verbessert um 3 Bytes. 2-Byte-Credits für Kevin. Vielen Dank

[Edit 2] 2 weitere Bytes verbessert. Dank an gastropner. Vielen Dank

J , 17 Bytes

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

Probieren Sie es online!

Erläuterung:

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

Vielen Dank für @Arnauld, der mich noch einmal daran erinnert hat, dass SpiderMonkey eine stabile Sortierung verwendet, also -4 Bytes zum Entfernen ||-1.

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

Probieren Sie es online!

JavaScript (Node.js) , 72 Byte

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

Probieren Sie es online!

Java (JDK) , 98 Byte

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

Probieren Sie es online!

Erläuterung

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

Hinweis:

Ich brauchte eine Möglichkeit, Nummern entweder 0/1oder zuzuordnen 0/-1.

indexOfhat die nette Eigenschaft, dass es -1für nicht gefundene Zeichen konsequent zurückgibt . -1um eine beliebige Zahl nach rechts verschoben ist immer -1. Jede positive Zahl, die um eine ausreichend große Zahl nach rechts verschoben wird, ergibt immer 0.

So hier sind wir:

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}

Probieren Sie es online!

Perl 5 -nl , 68 Bytes

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

Probieren Sie es online!

Julia 1.0 , 50 Bytes

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

Probieren Sie es online!

APL (NARS), 366 Zeichen, 732 Byte

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

Für den qsort-Operator ist es eine Übersetzung in APL von algo S. 139 K & R Linguaggio C. Ich denke, darin werden Daten als C mit Zeigern verwendet ... 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 Bytes

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

Testskript:

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

Ausgabe:

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

Laufen Sie mit -nroder versuchen Sie es online .

Ersetzen Sie ++$idurch $argc(+1 Byte), um den Hinweis zu unterdrücken (und -nobosolet zu machen ).

Nervenzusammenbruch

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

- ist "kleiner" als die Ziffern, hat also keinen Einfluss auf die Sortierung.

Common Lisp, 88 Bytes

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

Probieren Sie es online!

Gutes altes wortreiches Common Lisp!

Erläuterung:

(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 bis 74 Byte

-1 Danke, nur bei ASCII

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

Probieren Sie es online!

In C # werden Zeichenfolgen als "Enumerables" von Zeichen betrachtet. Ich nutze dies zu meinem Vorteil, indem ich zuerst jede Zahl in einen String umwandle. LINQ wird dann genutzt, um die eindeutigen Zeichen (Ziffern) in umgekehrter Reihenfolge zu sortieren. Ich konvertiere jedes sortierte Zeichenarray zurück in eine Zeichenfolge und verwende diese als Sortierschlüssel, um die gesamte Liste zu sortieren.