Wyzwanie:

Biorąc pod uwagę listę liczb całkowitych, posortuj malejąco według ich największych pojedynczych cyfr. Kolejność liczb o tej samej największej cyfrze jest następnie sortowana według drugiej największej cyfry itp.
Ignorujemy zduplikowane cyfry liczb. A jeśli wszystkie cyfry w liczbie są takie same, kolejność liczb na liście może być dowolna.

Przykład:

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]

Czemu? Oto odpowiednie cyfry, według których posortowano numery:

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

Zasady konkursu:

• Ignorujemy zduplikowane cyfry, więc 478i -7738będą zamawiane jako 478, -7738, ponieważ największe cyfry to [8,7,4]i [8,7,3], a nie [8,7,4]i [8,7,7,3].
• Jeśli wiele cyfr ma te same cyfry, ich kolejność może być dowolna. Więc 373i -73mogą być sortowane jako obie 373, -73lub -73, 373(cyfry dotyczą [7,3]obu tych liczb).
• Jeśli liczba nie zawiera więcej cyfr do sprawdzenia, zostanie umieszczona z tyłu odpowiednich liczb. Więc 123i 3120zostaną posortowane jako 3120, 123, ponieważ największe cyfry [3,2,1]są takie same, ale 0występują wcześniej none.
• Możesz założyć, że wszystkie liczby na wejściu są w zakresie [-999999,999999].
• Wystarczy jedno z możliwych wyników, ale możesz wypisać wszystkie możliwe dane wyjściowe, w których listy podrzędne mogą znajdować się w dowolnej permutacji, jeśli chcesz (chociaż wątpię, że zaoszczędziłoby to bajtów w dowolnym języku).

Główne zasady:

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
  Nie pozwól, aby języki gry w golfa zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
• Do odpowiedzi mają zastosowanie standardowe reguły z domyślnymi regułami We / Wy , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami i typem zwracanych, pełnych programów. Twoja decyzja.
• Domyślne luki są zabronione.
• Jeśli to możliwe, dodaj link z testem kodu (tj. TIO ).
• Zalecane jest również dodanie wyjaśnienia do odpowiedzi.

Przypadki testowe:

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 bajtów

ΣêR}R

Wypróbuj online! lub jako pakiet testowy

Wyjaśnienie

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

R , 97 95 bajtów

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

Wypróbuj online!

Wydaje się, że to wyzwanie zostało pesymizowane dla R. Wyjaśnienie oryginalnej wersji (zacznij od 1. i pracuj dalej):

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 bajtów

-1 bajt dzięki Jo King
-2 bajty dzięki Phil H.

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

Wypróbuj online!

Wyjaśnienie

       {                      }  # 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 bajtów

-1 bajt dzięki Jonasowi Auseviciusowi .

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

Wypróbuj online!

Bez golfa

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

Wypróbuj online!

Python 2 , 58 60 bajtów

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

Wypróbuj online!

Brachylog , 9 bajtów

{ȧdṫo₁}ᵒ¹

Uwaga: ze względu na to, jak działa porządkowanie w brachylogu, nie działa on poprawnie na numer. Jest to naprawione przez rzutowanie liczby na ciąg ( ṫ) kosztem 1 bajtu.

Wypróbuj online!

Pyth, 7 6 bajtów

-1 bajt @Sok

_o_{S`

Pyth, który używa tylko ASCII do wydruku, ma tutaj trochę wadę. Optymalnie zakodowane byłyby to 6*log(95)/log(256) = 4.927bajty, pokonując 05AB1E.

Wyjaśnił:

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

Wypróbuj tutaj .

Galaretka , 8 bajtów

ADṢUQµÞU

Wypróbuj online!

Jak to działa

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 bajtów

áÉ░▀zx

Wypróbuj online! lub jako pakiet testowy .

Wyjaśnienie

Po przyjrzeniu się rozwiązaniu Emigna 05AB1E stwierdziłem, że nie potrzebowałem operatora absolutnego (a moja poprzednia odpowiedź była właściwie nieprawidłowa z powodu tego operatora). Główną różnicą jest to, że przekształcam na ciąg znaków i otrzymuję unikalne znaki zamiast używania 1-bajtowego operatora w 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 bajtów

ñ_a ì â ñnÃw

Wszystkie przypadki testowe

Wyjaśnienie:

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

Haskell , 54 52 bajty

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

Wypróbuj online!

Stax , 6 7 bajtów

èó≥ü≤♥¥

Uruchom i debuguj

APL (Dyalog Extended) , 19 bajtów

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

Wypróbuj online!

Naprawiono kosztem +2 bajtów dzięki OP.

C (gcc) , 114 111 109 bajtów

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

Wypróbuj online!

Wyjaśnienie:

f () używa qsort () do sortowania podanej tablicy w miejscu. Korzystanie z funkcji porównania c () do porównywania liczb, które oceniają liczby za pomocą v (). v () oblicza wyższą liczbę, jeśli w parametrze występują większe cyfry.

[Edytuj 1] Poprawiono o 3 bajty. 2 bajty kredytów dla Kevina. Dzięki

[Edytuj 2] Ulepszono jeszcze 2 bajty. Kredyty dla gastropnera. Dzięki

J , 17 bajtów

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

Wypróbuj online!

Wyjaśnienie:

                @|    - 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 bajtów

Dzięki za @Arnauld za ponowne przypomnienie mi, że SpiderMonkey używa stabilnego sortowania, więc -4 bajtów do usunięcia ||-1.

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

Wypróbuj online!

JavaScript (Node.js) , 72 bajty

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

Wypróbuj online!

Java (JDK) , 98 bajtów

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

Wypróbuj online!

Wyjaśnienie

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

Uwaga:

Potrzebowałem sposobu na odwzorowanie liczb na albo 0/1albo 0/-1.

indexOfma tę fajną właściwość, że konsekwentnie zwraca -1znaki, których nie znaleziono. -1przesunięcie w prawo o dowolną liczbę jest zawsze -1. Każda liczba dodatnia przesunięta w prawo o wystarczająco dużą liczbę zawsze będzie generować 0.

I oto jesteśmy:

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

Rubinowy , 55 bajtów

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

Wypróbuj online!

Perl 5 -nl , 68 bajtów

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

Wypróbuj online!

Julia 1.0 , 50 bajtów

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

Wypróbuj online!

APL (NARS), 366 znaków, 732 bajty

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

Dla operatora qsort jest to jedna translacja w APL algo na stronie 139 K&R Linguaggio C. Myślę, że w tym jest wykorzystanie danych jako C ze wskaźnikami ... 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 bajty

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

Skrypt testowy:

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

Wydajność:

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 bajtów

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

Uruchom -nrlub wypróbuj online .

Wymienić ++$iz $argc(+ 1) bajtów do tłumienia ogłoszenia (i uczynić -nobosolete).

awaria

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

- jest „mniejszy” niż cyfry, więc nie ma wpływu na sortowanie.

Common Lisp, 88 bajtów

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

Wypróbuj online!

Dobry stary gadatliwy Common Lisp!

Wyjaśnienie:

(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 # (interaktywny kompilator Visual C #) , 75 74 bajtów

-1 dzięki @ tylko ASCII

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

Wypróbuj online!

W języku C # ciągi są uważane za „wyliczalne” znaków. Używam tego na swoją korzyść, najpierw konwertując każdą liczbę na ciąg. LINQ jest następnie wykorzystywany do sortowania unikalnych znaków (cyfr) w odwrotnej kolejności. Przekształcam każdą posortowaną tablicę znaków z powrotem na ciąg i używam tego jako klucza sortowania do uporządkowania całej listy.