चुनौती:

पूर्णांक की एक सूची को देखते हुए, उनके सबसे बड़े अंक (ओं) द्वारा उतरते हुए क्रमबद्ध करें। उसी सबसे बड़े अंक वाली संख्याओं के लिए क्रम दूसरे सबसे बड़े अंकों के आधार पर क्रमबद्ध होता है, आदि
हम संख्याओं में डुप्लिकेट अंकों की उपेक्षा करते हैं। और यदि किसी संख्या में सभी अंक समान हैं, तो सूची में उन संख्याओं का क्रम किसी भी तरह से हो सकता है जो आप चाहते हैं।

उदाहरण:

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]।
परिणाम के रूप में संभावित आउटपुट में से केवल एक ही पर्याप्त है, लेकिन आपको उन सभी संभावित आउटपुट को आउटपुट करने की अनुमति है जहां सब्लिस्ट किसी भी क्रम में हो सकते हैं यदि आप चाहें (हालांकि मुझे संदेह है कि यह किसी भी भाषा में बाइट्स को बचाएगा)।

सामान्य नियम:

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव कम उत्तर के साथ आने की कोशिश करें।
डिफ़ॉल्ट I / O नियमों के साथ आपके उत्तर के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ 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]

— केविन क्रूज़सेन
स्रोत

6

05AB1E , 5 बाइट्स

ΣêR}R

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

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

— Emigna
स्रोत

7

आर , 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
              )
        )
    ]
}

— एन जी एम
स्रोत

6

पर्ल 6 , 36 34 33 31 बाइट्स

जो किंग को बाइट की बदौलत -1 बाइट,
फिल एच को धन्यवाद

*.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

— nwellnhof
स्रोत

1

अच्छा! के लिए गमागमन के m:g/\d./लिए -2 बाइट्स .abs.comb: tio.run/…

— Phil H

6

पायथन 2 , 60 55 54 बाइट्स

जोनास ऑसेविसियस को -1 बाइट धन्यवाद ।

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

इसे ऑनलाइन आज़माएं!

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

इसे ऑनलाइन आज़माएं!

— OVS
स्रोत

5

Noneसमारोह cmpमें बदला जा सकता हैsort

— जोनास ऑसेविसियस

मुझे लगता है कि [:: - 1] का दोहरा नकार के लिए आदान-प्रदान किया जा सकता है।

— डॉनक्यूइकॉन्ग

@DonQuiKong जो कि अभी थोड़ा लंबा होगा, क्योंकि अंक सभी तार हैं, और इसके लिए इन्टस में परिवर्तित करने की आवश्यकता होगी।

— ओव्स

@JonasAusevicius बहुत बहुत धन्यवाद।

— ओव्स

5

पायथन 2 , 58 60 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— जोनास ऑसेविसियस
स्रोत

5

ब्रेकीलॉग , 9 बाइट्स

{ȧdṫo₁}ᵒ¹

नोट: कैसे ऑर्डर करने के कारण ब्राचीलॉग में काम करता है, यह सही ढंग से नंबर पर काम नहीं करता है। यह ṫ1 बाइट की लागत पर संख्या को एक स्ट्रिंग ( ) में कास्टिंग करके तय किया गया है ।

इसे ऑनलाइन आज़माएं!

— Kroppeb
स्रोत

2

आपका क्या मतलब है " ब्राचीलॉग में ऑर्डर करने का काम कैसे किया जाता है, यह इरादा के अनुसार काम नहीं करता है। " मैंने सभी चार परीक्षण मामलों की कोशिश की है, और इसके सही परिणाम दे रहा है (जब तक कि मैं गलती से किसी चीज को नहीं देखता)।

— केविन क्रूज़सेन

@KevinCruijssen ṫ(स्ट्रिंग को) समस्या को हल करता है। एक संख्या में अवरोही क्रमों का क्रम निम्नानुसार है। सबसे छोटे से सबसे बड़े और फिर रिवर्स के लिए ऑर्डर करें। समस्या यह है कि 3120सबसे छोटी से सबसे बड़ी संख्या का आदेश दिया गया है, 0123जो 123कि उलट के बराबर है 321और नहीं3210

— क्रॉपेब

2

आह ठीक है, इसलिए आपका वर्तमान कोड जोड़ा गया स्ट्रींग ( ṫ) के कारण काम कर रहा है । जैसा कि @Arnauld द्वारा उल्लेख किया गया है, मुझे लगा कि आपकी टिप्पणी का मतलब है कि आपका वर्तमान कोड काम नहीं करता है। इसका उल्लेख करना बेहतर हो सकता है जैसे: " यह ṫ(toString) को हटाकर 8 बाइट्स हो सकता था , लेकिन दुर्भाग्य से यह

— ब्राचिग्लोग

जो मैंने लिखा है उसे देखकर ऐसा लगता है कि मेरे मस्तिष्क में विचलितता छा गई। ठीक कर दिया।

— क्रॉपेब

5

पायथ, 7 6 बाइट्स

-1 बाइट @ सोक द्वारा

_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.

इसे यहाँ आज़माएँ ।

— lirtosiast
स्रोत

2

N1 बाइट को बचाने के लिए ट्रेलिंग को छोड़ा जा सकता है - सभी लैम्ब्डा-प्रकार के कार्य सिद्धांत लैम्ब्डा वेरिएबल की उपस्थिति का अनुमान लगाते हैं यदि कोई तर्क अंत से गायब है। उदाहरणों में शामिल हैं , mइंफ्रारेडिंग d, fइनफ़ेक्टरी T, uइनफ़ेक्शन G...

— सोक

4

जेली , 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

— bubbler
स्रोत

2

मैंने अभी इस पर अमल किया तब आपकी पोस्ट मिली। मैं सामान्य उलटफेर के साथ गया Ṛ, बजाय उठाव के U। ध्यान दें, हालांकि, आपको उस Dप्रकार की आवश्यकता नहीं है Ṣ, iterable(z, make_digits=True)जिसे अंदर कॉल के साथ लागू किया गया है। तो यह AṢQṚµÞṚ7. के लिए था

— जोनाथन एलन

3

मठगोल्फ , 7 6 बाइट्स

áÉ░▀zx

इसे ऑनलाइन आज़माएं! या एक परीक्षण सूट के रूप में ।

व्याख्या

एमिग्ना के 05AB1E समाधान को देखने के बाद, मैंने पाया कि मुझे पूर्ण ऑपरेटर की आवश्यकता नहीं थी (और मेरा पिछला जवाब वास्तव में उस ऑपरेटर की वजह से गलत था)। अब मुख्य अंतर यह है कि मैं स्ट्रिंग को परिवर्तित करता हूं और 05AB1E में 1-बाइट ऑपरेटर का उपयोग करने के बजाय अद्वितीय वर्ण प्राप्त करता हूं।

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

— maxb
स्रोत

3

जाप , 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

— कामिल दकरी
स्रोत

3

हास्केल , 54 52 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— मार्टिन लुटके
स्रोत

परिभाषित r=reverseदो बाइट्स बचाता है। हम अनाम कार्यों को भी अनुमति देते हैं, इसलिए इसे f=गिनने की आवश्यकता नहीं है।

— लाकोनी

मैंने आयात और f = को TIO हेडर में स्थानांतरित कर दिया। क्या वह ठीक है?

— मार्टिन लोटके

एक ही बाइट गिनती, लेकिन शायद कुछ ब्याज की f=r$r id.nub.show;r=(reverse.).sortOn:।

— लाकोनी

1

आयात वास्तव में गिना जाना चाहिए।

— लाकोनी

2

आप हास्केल में गोल्फ गाइड के नियमों पर हमारी नज़र डाल सकते हैं ।

— लाइकोनी

3

स्टैक्स , 6 7 बाइट्स

èó≥ü≤♥¥

इसे चलाएं और डीबग करें

— पुनरावर्ती
स्रोत

यह गलत परिणाम देता है। उदाहरण के लिए, आपके TIO के परीक्षण मामले में यह -904 8491 478 62778 6458 -7738 -73 373 123 3120 0इच्छित 8491 -904 62778 478 -7738 6458 373 -73 3120 123 0या के बजाय आउटपुट देता है 8491 -904 62778 478 -7738 6458 -73 373 3120 123 0। इस परीक्षण मामले का उपयोग उदाहरण में, और नियमों को समझाने के लिए किया जाता है, इसलिए मैं इसे बेहतर समझने के लिए इस पर एक नज़र डालूंगा। ऐसा लगता है कि आप केवल एक बार सबसे बड़े अंक द्वारा छांट रहे हैं, अन्य नियमों के बिना?

— केविन क्रूज़सेन

@ केविनक्रूजसेन: हां, मेरी क्षमायाचना। मैंने समस्या कथन को गलत पढ़ा। मैंने बताई गई आवश्यकताओं को संभालने के लिए कार्यक्रम को समायोजित किया है। यह प्रोग्राम इनपुट पूर्णांक को उद्धृत स्ट्रिंग्स के रूप में स्वीकार कर रहा है। यह आमतौर पर स्वीकार्य है, लेकिन अगर मुझे एक और बाइट जोड़ने की आवश्यकता नहीं है।

— पुनरावर्ती

अब मुझसे अच्छा लगता है, +1। और हां, स्ट्रिंग्स के रूप में इनपुट करना पूरी तरह से ठीक है।

— केविन क्रूज़सेन

3

एपीएल (डायलॉग एक्सटेंडेड) , 19 बाइट्स

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

इसे ऑनलाइन आज़माएं!

ओपी के लिए धन्यवाद +2 बाइट्स की लागत पर फिक्स्ड।

— जाकारी
स्रोत

मुझे लगता है कि आप कहीं एक 'अद्वितीय' याद कर रहे हैं? यदि मैं उदाहरण के लिए आपके TIO में उदाहरण परीक्षण मामले की कोशिश करता हूं, ¯7738तो पहले रखा गया है 478, लेकिन यह इसके बाद होना चाहिए: अंक अंकों [8,7,4]से पहले आते हैं [8,7,3]।

— केविन क्रूज़सेन

धन्यवाद, @KevinCruijssen

— Zacharý

3

सी (जीसीसी) , 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 और बाइट्स में सुधार हुआ। गैस्ट्रोपनर को श्रेय। धन्यवाद

— GPS
स्रोत

1

आप गोल्फ कर सकते हैं n>0करने के लिए nमैं अपने विधि के अपने पाश में लगता है v।

— केविन क्रूज़सेन

f () की तर्क सूची int*a,nको छोटा किया जा सकता है int*a।

— गैस्ट्रोपनर

1

for(a=0;n=abs(n);इसके बजाय सुझाव देंn=n<0?-n:n;for(a=0;n;

— छत सी

2

जे , 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

— गैलेन इवानोव
स्रोत

2

जावास्क्रिप्ट (स्पाइडरमोनी) , 68 बाइट्स

@Arnauld के लिए मुझे फिर से याद दिलाने के लिए धन्यवाद कि स्पाइडरमोंकी स्थिर प्रकार का उपयोग करता है, इसलिए हटाने के लिए -4 बाइट्स ||-1।

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

इसे ऑनलाइन आज़माएं!

जावास्क्रिप्ट (Node.js) , 72 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— शायरु असकोतो
स्रोत

या स्पाइडरमैन के साथ 68 बाइट्स ।

— अरनौलद

1

@ अर्नुलद ओह स्टेबल सॉर्ट फ़िर; पी

— शायरु असाकोतो

10

$10$

1

@Arnauld V8 क्रोम 70 से पहले त्वरित प्रकार का उपयोग करता है। त्वरित आकार एल्गोरिथ्म एक सम्मिलन प्रकार का प्रदर्शन करता है जब सरणी आकार काफी छोटा होता है। और नवीनतम क्रोम अन्य ब्राउज़रों के मिलान (IE / Firefox / Safari) के व्यवहार के लिए स्थिर प्रकार में बदल गया था।

— tsh

2

जावा (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

— ओलिवियर ग्रेजायर
स्रोत

1

आह, हाँ, मेरा यही मतलब है। पी । संख्या की सीमित सीमा के कारण उपयोग >>9करने का अच्छा गोल्फ >>32।

— केविन क्रूज़सेन 12

1

रूबी , 55 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— किरिल एल।
स्रोत

1

पर्ल 5 `-nl` , 68 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— Xcali
स्रोत

1

जूलिया 1.0 , 50 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— किरिल एल।
स्रोत

1

एपीएल (एनएआरएस), 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 ऑपरेटर के लिए, यह एल्गो पेज 139 K & R Linguaggio C. के APL में एक ट्रैस्लेशन है। मुझे लगता है कि इसमें पॉइंटर्स के साथ 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

— RosLuP
स्रोत

1

पॉवरशेल, 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

— Mazzy
स्रोत

1

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

- अंकों से "छोटा" है, इसलिए छँटाई पर इसका कोई प्रभाव नहीं है।

— टाइटस
स्रोत

1

आम लिस्प, 88 बाइट्स

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

इसे ऑनलाइन आज़माएं!

अच्छी पुरानी क्रिया आम लिस्प!

स्पष्टीकरण:

(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

— रेंज़ो
स्रोत

1

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 75 74 बाइट्स

-1 धन्यवाद @ ASCII- ही

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

इसे ऑनलाइन आज़माएं!

C # में, स्ट्रिंग्स को वर्णों के "एनुमेरैबल्स" माना जाता है। मैं पहले नंबर पर एक स्ट्रिंग में परिवर्तित करके अपने लाभ के लिए इसका उपयोग करता हूं। LINQ को तब उल्टे क्रम में क्रमबद्ध अद्वितीय वर्ण (अंक) प्राप्त करने के लिए लगाया जाता है। मैं प्रत्येक क्रमबद्ध वर्ण सरणी को एक स्ट्रिंग में परिवर्तित करता हूं और पूरी सूची को क्रमबद्ध करने के लिए उस कुंजी का उपयोग करता हूं।

— दाना
स्रोत

लगता है कि आप नहीं जोड़ने के साथ दूर हो जाएगा -, लगता है उन लोगों के आदेश वास्तव में कोई फर्क नहीं पड़ता?

— केवल

-टेस्ट केस के बिना , # 2 रिटर्न ... 321 2132 ...जो गलत लगता है?

— दाना

nah, उदाहरण को और अधिक ध्यान से पढ़ें

— ASCII-only

ठीक है - मुझे तुम्हारा अधिकार लगता है। पारितोषिक के लिए धन्यवाद!

— दना

सबसे बड़े अंक के आधार पर छाँटें

चुनौती:

चुनौती नियम:

सामान्य नियम:

परीक्षण के मामलों:

05AB1E , 5 बाइट्स

आर , 97 95 बाइट्स

पर्ल 6 , 36 34 33 31 बाइट्स

व्याख्या

पायथन 2 , 60 55 54 बाइट्स

Ungolfed

पायथन 2 , 58 60 बाइट्स

ब्रेकीलॉग , 9 बाइट्स

पायथ, 7 6 बाइट्स

जेली , 8 बाइट्स

यह काम किस प्रकार करता है

मठगोल्फ , 7 6 बाइट्स

व्याख्या

जाप , 12 बाइट्स

हास्केल , 54 52 बाइट्स

स्टैक्स , 6 7 बाइट्स

एपीएल (डायलॉग एक्सटेंडेड) , 19 बाइट्स

सी (जीसीसी) , 114 111 109 बाइट्स

जे , 17 बाइट्स

स्पष्टीकरण:

जावास्क्रिप्ट (स्पाइडरमोनी) , 68 बाइट्स

जावास्क्रिप्ट (Node.js) , 72 बाइट्स

जावा (JDK) , 98 बाइट्स

व्याख्या

रूबी , 55 बाइट्स

पर्ल 5 -nl , 68 बाइट्स

जूलिया 1.0 , 50 बाइट्स

एपीएल (एनएआरएस), 366 चार्ट, 732 बाइट्स

पॉवरशेल, 44 बाइट्स

PHP, 87 86 84 बाइट्स

आम लिस्प, 88 बाइट्स

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 75 74 बाइट्स

पर्ल 5 `-nl` , 68 बाइट्स