Sfida:

Dato un elenco di numeri interi, ordina in ordine decrescente per le singole cifre più grandi. L'ordine per i numeri con la stessa cifra più grande viene quindi ordinato in base alla seconda cifra più grande, ecc.
Ignoriamo le cifre duplicate nei numeri. E se tutte le cifre di un numero sono uguali, l'ordine di quei numeri nell'elenco può essere come desideri.

Esempio:

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]

Perché? Ecco le cifre rilevanti su cui sono stati ordinati i numeri:

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

Regole della sfida:

• Ignoriamo le cifre duplicate, quindi 478e -7738verranno ordinate come 478, -7738, perché le cifre più grandi sono [8,7,4]e [8,7,3], e non [8,7,4]e [8,7,7,3].
• Se più numeri hanno le stesse cifre, l'ordine di questi può essere in entrambi i modi. Quindi 373e -73può essere ordinato come entrambi 373, -73o -73, 373(le cifre sono [7,3]per entrambi questi numeri).
• Se un numero non contiene più cifre da controllare, verrà inserito sul retro dei numeri pertinenti. Quindi 123e 3120saranno ordinati come 3120, 123, perché le cifre più grandi [3,2,1]sono uguali, ma 0viene prima none.
• Puoi presumere che tutti i numeri nell'input siano compresi nell'intervallo [-999999,999999].
• Di conseguenza, è sufficiente solo una delle uscite possibili, ma è possibile generare tutte le uscite possibili in cui le liste secondarie possono essere in qualsiasi permutazione, se lo si desidera (anche se dubito che salverebbe byte in qualsiasi lingua).

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard con regole I / O predefinite , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice (ad es. TIO ).
• Inoltre, si consiglia vivamente di aggiungere una spiegazione per la risposta.

Casi 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 byte

ΣêR}R

Provalo online! o come una suite di test

Spiegazione

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

R , 97 95 byte

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

Provalo online!

Questa sfida sembra essere stata pessimizzata per R. Spiegazione della versione originale (inizia da 1. e risolvi):

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 byte

-1 byte grazie a Jo King
-2 byte grazie a Phil H

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

Provalo online!

Spiegazione

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

-1 byte grazie a Jonas Ausevicius .

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

Provalo 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

Provalo online!

Python 2 , 58 60 byte

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

Provalo online!

Brachylog , 9 byte

{ȧdṫo₁}ᵒ¹

Nota: a causa di come funziona l'ordinamento in brachylog, non funziona correttamente sul numero. Questo viene risolto lanciando il numero su una stringa ( ṫ) al costo di 1 byte.

Provalo online!

Pyth, 7 6 byte

-1 byte di @Sok

_o_{S`

Pyth, che utilizza solo ASCII stampabile, è un po 'svantaggiato qui. Codificato in modo ottimale, questo sarebbe 6*log(95)/log(256) = 4.927byte, battendo 05AB1E.

Ha spiegato:

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

Provalo qui .

Gelatina , 8 byte

ADṢUQµÞU

Provalo online!

Come funziona

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 byte

áÉ░▀zx

Provalo online! o come suite di test .

Spiegazione

Dopo aver esaminato la soluzione 05AB1E di Emigna, ho scoperto che non avevo bisogno dell'operatore assoluto (e la mia risposta precedente era effettivamente errata a causa di quell'operatore). Ora la differenza principale è che converto in stringa e ottengo caratteri univoci invece di utilizzare l'operatore a 1 byte in 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 byte

ñ_a ì â ñnÃw

Tutti i casi di test

Spiegazione:

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

Haskell , 54 52 byte

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

Provalo online!

Stax , 6 7 byte

èó≥ü≤♥¥

Esegui ed esegui il debug

APL (Dyalog Extended) , 19 byte

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

Provalo online!

Risolto con un costo di +2 byte grazie a OP.

C (gcc) , 114 111 109 byte

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

Provalo online!

Spiegazione:

f () usa qsort () per ordinare in posizione l'array fornito. Utilizzando la funzione di confronto c () per confrontare i numeri che valuta i numeri usando v (). v () calcola un numero più alto se nel parametro sono presenti cifre più grandi.

[Modifica 1] Migliorato di 3 byte. Crediti da 2 byte a Kevin. Grazie

[Modifica 2] 2 byte in più migliorati. Crediti a gastropner. Grazie

J , 17 byte

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

Provalo online!

Spiegazione:

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

Grazie per @Arnauld per avermi ricordato di nuovo che SpiderMonkey utilizza un ordinamento stabile, quindi -4 byte per la rimozione ||-1.

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

Provalo online!

JavaScript (Node.js) , 72 byte

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

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

Provalo online!

Spiegazione

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:

Avevo bisogno di un modo per mappare i numeri su 0/1o 0/-1.

indexOfha la bella proprietà che ritorna costantemente -1per i personaggi non trovati. -1spostato a destra di qualsiasi numero è sempre -1. Qualsiasi numero positivo spostato a destra di un numero abbastanza grande produrrà sempre 0.

Allora eccoci qua:

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

Rubino , 55 byte

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

Provalo online!

Perl 5 -nl , 68 byte

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

Provalo online!

Julia 1.0 , 50 byte

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

Provalo online!

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

Per l'operatore qsort, si tratta di una traslazione in APL di algo pagina 139 K&R Linguaggio C. Penso che in esso vengano utilizzati i dati come C con puntatori ... 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 byte

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

Script di prova:

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

Produzione:

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 byte

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

Corri con -nro provalo online .

Sostituisci ++$icon $argc(+1 byte) per sopprimere l'avviso (e renderlo -nobsoleto).

abbattersi

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

- è "più piccolo" delle cifre, quindi non ha alcun effetto sull'ordinamento.

Lisp comune, 88 byte

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

Provalo online!

Buon vecchio prolisso Lisp comune!

Spiegazione:

(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 # (compilatore interattivo Visual C #) , 75 74 byte

-1 grazie solo a ASCII

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

Provalo online!

In C #, le stringhe sono considerate "enumerabili" di caratteri. Lo uso a mio vantaggio convertendo prima ogni numero in una stringa. LINQ viene quindi sfruttato per ottenere i caratteri unici (cifre) ordinati in ordine inverso. Riconduco ogni array di caratteri ordinati in una stringa e lo uso come chiave di ordinamento per ordinare l'intero elenco.