Meydan okuma:

Bir tamsayı listesi verildiğinde, en büyük basamaklarına göre azalan sıralama. Aynı en büyük basamağa sahip numaraların sırası, daha sonra ikinci en büyük basamağa vb. Göre sıralanır
. Ve bir sayıdaki tüm rakamlar aynıysa, listedeki bu numaraların sırası istediğiniz şekilde olabilir.

Örnek:

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]

Niye ya? Sayıların sıralandığı ilgili rakamlar:

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

Meydan okuma kuralları:

• Biz yinelenen basamak yoksaydığından 478ve -7738şekilde sıralanır 478, -7738büyük rakam olduğu için, [8,7,4]ve [8,7,3], ve [8,7,4]ve [8,7,7,3].
• Birden fazla numara aynı rakamlara sahipse, bunların sırası her iki şekilde de olabilir. Yani 373ve -73her ikisi olarak 373, -73da sıralanabilir veya -73, 373( [7,3]bu rakamların her ikisi için de rakamlar).
• Bir sayı kontrol edilecek daha fazla basamak içermiyorsa, ilgili numaraların arkasına yerleştirilir. Böylece 123ve en büyük rakamlar aynı olduğundan, ancak daha önce geldiği 3120için sıralanacaktır .3120, 123[3,2,1]0none
• Girişteki tüm sayıların aralık içinde olduğunu varsayabilirsiniz [-999999,999999].
• Sonuç olarak olası çıktılardan yalnızca biri yeterlidir, ancak istediğinizde alt listelerin herhangi bir permütasyonda olabileceği tüm olası çıktıların çıktısını almanıza izin verilir (her ne kadar herhangi bir dilde bayt kazandıracağından şüphelenmeme rağmen).

Genel kurallar:

• Bu kod golf , bayt cinsinden en kısa cevap kazanır.
  Code-golf dillerinin, codegolfing olmayan dillerle cevap göndermekten vazgeçmesine izin vermeyin. Herhangi bir programlama dili için mümkün olduğunca kısa bir cevap bulmaya çalışın.
• Standart G / Ç kurallarına cevabınız için standart kurallar geçerlidir , bu nedenle STDIN / STDOUT işlevlerini, uygun parametreleri içeren fonksiyonlar / yöntemleri ve dönüş tipini, tam programları kullanmanıza izin verilir. Senin çağrı.
• Varsayılan Loopholes yasaktır.
• Mümkünse, lütfen kodunuzu test eden bir bağlantı ekleyin (ör. TIO ).
• Ayrıca, cevabınız için bir açıklama eklemek şiddetle tavsiye edilir.

Test durumları:

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 bayt

ΣêR}R

Çevrimiçi deneyin! veya Test paketi olarak

açıklama

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

R , 97 95 bayt

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

Çevrimiçi deneyin!

Bu zorluğun R için önceden belirlenmiş olduğu görülüyor. Orijinal versiyonun açıklaması (1. sınıftan başlar ve çalışır):

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 bayt

Jo King sayesinde -1 bayt
- Phil H sayesinde -2 bayt

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

Çevrimiçi deneyin!

açıklama

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

Jonas Ausevicius'a -1 bayt teşekkürler .

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

Çevrimiçi deneyin!

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

Çevrimiçi deneyin!

Python 2 , 58 60 bayt

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

Çevrimiçi deneyin!

Brachylog , 9 bayt

{ȧdṫo₁}ᵒ¹

Not: Siparişin brakilogda nasıl çalıştığından dolayı, numara üzerinde doğru şekilde çalışmaz. Bu sayı ṫ1 bayt pahasına bir dizgiye ( ) dönüştürülerek düzeltilir .

Çevrimiçi deneyin!

Pyth, 7 6 bayt

-1 bayt by @Sok

_o_{S`

Yalnızca yazdırılabilir ASCII kullanan Pyth, burada biraz dezavantajlı durumda. Optimal olarak kodlanmış bu 6*log(95)/log(256) = 4.927, 05AB1E'yi dayak bayt olacaktır .

Açıklaması:

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

Burada dene .

Jöle , 8 bayt

ADṢUQµÞU

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

áÉ░▀zx

Çevrimiçi deneyin! veya bir test takımı olarak .

açıklama

Emigna'nın 05AB1E çözümüne baktıktan sonra, mutlak operatöre ihtiyacım olmadığına karar verdim (ve önceki cevabım bu operatör yüzünden yanlıştı). Şimdi asıl fark, 05AB1E'deki 1-byte işlecini kullanmak yerine string'e dönüştürmek ve benzersiz karakterler elde etmem.

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

ñ_a ì â ñnÃw

Tüm test durumları

Açıklama:

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

Haskell , 54 52 bayt

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

Çevrimiçi deneyin!

Stax , 6 7 bayt

èó≥ü≤♥¥

Koş ve hata ayıkla

APL (Dyalog Genişletilmiş) , 19 bayt

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

Çevrimiçi deneyin!

OP sayesinde +2 bayt pahasına düzeltildi.

C (gcc) , 114 111 109 bayt

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

Çevrimiçi deneyin!

Açıklama:

f (), verilen diziyi yerinde sıralamak için qsort () işlevini kullanır. V () kullanarak sayıları değerlendiren sayıları karşılaştırmak için c () karşılaştırma işlevini kullanma. v () parametre içinde daha büyük basamaklar varsa daha yüksek bir sayı hesaplar.

[Düzenle 1] 3 byte tarafından geliştirilmiştir. Kevin'e 2 baytlık kredi. Teşekkürler

[Düzenle 2] 2 bayt daha iyileştirildi. Gastropner'e krediler. Teşekkürler

J , 17 bayt

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

Çevrimiçi deneyin!

Açıklama:

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

@Arnauld için teşekkürler, SpiderMonkey’in sabit bir sıralama kullandığını, bu yüzden kaldırma için -4 bayt olduğunu tekrar hatırlattığın için ||-1.

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

Çevrimiçi deneyin!

JavaScript (Node.js) , 72 bayt

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

Çevrimiçi deneyin!

Java (JDK) , 98 bayt

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

Çevrimiçi deneyin!

açıklama

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

Not:

Numaraları 0/1veya ile eşlemek için bir yola ihtiyacım vardı 0/-1.

indexOf-1Bulunamayan karakterler için sürekli olarak döndüren hoş bir özelliği var . -1herhangi bir sayı ile sağa kaydırma her zaman -1. Yeterince büyük bir sayı tarafından sağa kaydırılan pozitif sayılar her zaman üretecektir 0.

Yani buradayız:

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

Ruby , 55 bayt

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

Çevrimiçi deneyin!

Perl 5 -nl , 68 bayt

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

Çevrimiçi deneyin!

Julia 1.0 , 50 bayt

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

Çevrimiçi deneyin!

APL (NARS), 366 karakter, 732 bayt

_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 operatörü için, bu, algo APL'sindeki bir değerdir sayfa 139 K&R Linguaggio 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 bayt

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

Test komut dosyası:

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

Çıktı:

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 bayt

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

Çevrimiçi olarak çalıştırın -nrveya deneyin .

Bildirimi bastırmak (+ obosolete) ++$iyapmak için $argc(+1 byte) ile değiştirin -n.

Yıkmak

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

- basamaklardan "daha küçük" olduğundan, sıralama üzerinde hiçbir etkisi yoktur.

Ortak Lisp, 88 bayt

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

Çevrimiçi deneyin!

Eski güzel ayrıntılı Common Lisp!

Açıklama:

(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 # Etkileşimli Derleyici) , 75 74 bayt

-1 teşekkürler @ ASCII-sadece

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

Çevrimiçi deneyin!

C # 'da, karakter dizilerinin "numaralandırılabilir" olduğu kabul edilir. Her sayıyı bir dizgeye dönüştürerek önce bunu avantajım için kullanıyorum. LINQ daha sonra benzersiz karakterleri (rakamları) ters sırayla sıralamak için kullanılır. Her sıralı karakter dizisini tekrar bir dizgeye dönüştürürüm ve tüm listeyi sıralamak için bunu sıralama anahtarı olarak kullanırım.