Виклик:

Дано список цілих чисел, сортуйте по низхідному порядку за їх найбільшою цифрою. Порядок для чисел з однаковою великою цифрою потім сортується за другою найбільшою цифрою тощо.
Ми ігноруємо дублювані цифри в числах. І якщо всі цифри в числі однакові, порядок цих чисел у списку може бути будь-яким потрібним вам способом.

Приклад:

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]

Чому? Ось відповідні цифри, за якими були відсортовані номери:

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

Правила виклику:

• Ми ігноруємо дубльовані цифри, так 478і -7738будуть замовлені 478, -7738, так як найбільші цифри [8,7,4]і [8,7,3], а не [8,7,4]та [8,7,7,3].
• Якщо кілька чисел мають однакові цифри, то порядок їх може бути будь-яким. Так 373і -73можуть бути відсортовані як 373, -73або -73, 373(цифри [7,3]для обох цих чисел).
• Якщо число не містить більше цифр для перевірки, воно буде розміщене на звороті відповідних номерів. Так 123і 3120буде відсортовано як 3120, 123, бо найбільші цифри [3,2,1]однакові, але 0приходять раніше none.
• Можна припустити, що всі цифри на вході знаходяться в діапазоні [-999999,999999].
• В результаті вистачає лише одного з можливих результатів, але вам дозволяється виводити всі можливі результати, де сублісти можуть бути в будь-якій перестановці, якщо хочете (хоча, я сумніваюся, це дозволить зберегти байти на будь-якій мові).

Загальні правила:

• Це код-гольф , тому найкоротша відповідь у байтах виграє.
  Не дозволяйте мовам коду-гольфу відштовхувати вас від публікації відповідей з не кодовими гольф-мовами. Спробуйте придумати якомога коротшу відповідь на "будь-яку" мову програмування.
• Для вашої відповіді застосовуються стандартні правила з правилами вводу / виводу за замовчуванням , тому вам дозволяється використовувати STDIN / STDOUT, функції / метод із відповідними параметрами та повним програмами типу повернення. Твій дзвінок.
• Лазівки за замовчуванням заборонені.
• Якщо можливо, додайте посилання з тестом для вашого коду (тобто TIO ).
• Також настійно рекомендується додавати пояснення до своєї відповіді.

Тестові приклади:

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 байт

ΣêR}R

Спробуйте в Інтернеті! або як тестовий набір

Пояснення

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

R , 97 95 байт

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

Спробуйте в Інтернеті!

Здається, цей виклик песимізовано для Р. Пояснення оригінальної версії (початок з 1. і розробка):

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 байт

-1 байт завдяки Джо Кінгу
-2 байти завдяки Філу Н

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

Спробуйте в Інтернеті!

Пояснення

       {                      }  # 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 байт

-1 байт завдяки Йонасу Аусевічусу .

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

Спробуйте в Інтернеті!

Безумовно

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

Спробуйте в Інтернеті!

Python 2 , 58 60 байт

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

Спробуйте в Інтернеті!

Брахілог , 9 байт

{ȧdṫo₁}ᵒ¹

Примітка: завдяки тому, як замовлення працює у брахілограмі, воно не працює на номер правильно. Це фіксується, перекинувши число в рядок ( ṫ) за вартістю 1 байт.

Спробуйте в Інтернеті!

Pyth, 7 6 байт

-1 байт від @Sok

_o_{S`

Pyth, який використовує лише друкований ASCII, тут трохи не вигідний. Оптимально закодованим було б 6*log(95)/log(256) = 4.927байти, побивши 05AB1E.

Пояснили:

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

Спробуйте тут .

Желе , 8 байт

ADṢUQµÞU

Спробуйте в Інтернеті!

Як це працює

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 байт

áÉ░▀zx

Спробуйте в Інтернеті! або як тестовий набір .

Пояснення

Переглянувши рішення 05AB1E Emigna, я виявив, що мені не потрібен абсолютний оператор (і моя попередня відповідь була фактично неправильною через цього оператора). Тепер головна відмінність полягає в тому, що я перетворюю на рядок і отримую унікальні символи замість того, щоб використовувати 1-байтовий оператор у 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 байт

ñ_a ì â ñnÃw

Усі тестові справи

Пояснення:

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

Haskell , 54 52 байти

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

Спробуйте в Інтернеті!

Стакс , 6 7 байт

èó≥ü≤♥¥

Запустіть і налагоджуйте його

APL (Dyalog Extended) , 19 байт

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

Спробуйте в Інтернеті!

Виправлено вартістю +2 байти завдяки ОП.

C (gcc) , 114 111 109 байт

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

Спробуйте в Інтернеті!

Пояснення:

f () використовує qsort () для сортування наданого масиву на місці. Використання функції порівняння c () для порівняння чисел, що оцінює числа за допомогою v (). v () обчислює більше число, якщо в параметрі присутні більші цифри.

[Редагувати 1] Покращено на 3 байти. 2 байт-кредити Кевіну. Спасибі

[Редагувати 2] Удосконалено ще 2 байти. Кредити гастропнеру. Спасибі

J , 17 байт

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

Спробуйте в Інтернеті!

Пояснення:

                @|    - 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 байт

Дякую за @Arnauld, що знову нагадав мені, що SpiderMonkey використовує стабільний сорт, тож 4 ​​байти для видалення ||-1.

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

Спробуйте в Інтернеті!

JavaScript (Node.js) , 72 байти

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

Спробуйте в Інтернеті!

Java (JDK) , 98 байт

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

Спробуйте в Інтернеті!

Пояснення

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

Примітка:

Мені потрібен був спосіб відображення чисел на 0/1або 0/-1.

indexOfмає приємне властивість, що вона постійно повертається -1для символів, не знайдених. -1правий зсув на будь-яке число є завжди -1. Будь-яке додатне число, зміщене праворуч на достатньо велике число, завжди створюватиме 0.

Отже, ось ми:

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

Рубін , 55 байт

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

Спробуйте в Інтернеті!

Perl 5 -nl , 68 байт

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

Спробуйте в Інтернеті!

Джулія 1,0 , 50 байт

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

Спробуйте в Інтернеті!

APL (NARS), 366 символів, 732 байт

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

Для оператора qsort це одна перекладка в APL альго сторінки 139 K&R Linguaggio C. Я думаю, що в ній використовується дані як C з покажчиками ... Тест

 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 байти

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

Тестовий сценарій:

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

Вихід:

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 байт

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

Запустіть -nrабо спробуйте в Інтернеті .

Замінити ++$iз $argc(+1 байт) , щоб придушити Повідомлення (і візуалізації -nobosolete).

зламатися

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

- "менше", ніж цифри, тому це не впливає на сортування.

Лист звичайний, 88 байт

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

Спробуйте в Інтернеті!

Старий добрий багатослівний Common Lisp!

Пояснення:

(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 байт

-1 спасибі лише для ASCII

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

Спробуйте в Інтернеті!

У C # рядки вважаються "перелічувальними" символами. Я використовую це з моєю користю, спочатку перетворюючи кожне число в рядок. Потім LINQ використовується для отримання унікальних символів (цифр), відсортованих у зворотному порядку. Я перетворюю кожен відсортований масив символів назад у рядок і використовую його як ключ сортування для замовлення всього списку.