डिजिट जोड़े जो बताते हैं, उसके आधार पर छाँटें

Question

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

उदाहरण के लिए:

• 1234 को एक 2, तीन 4s के रूप में पढ़ा जा सकता है - इसलिए, 1234 का आउटपुट 2444 है।

• 643 अंकों की एक विषम संख्या है, इसलिए इसे बनाने के लिए एक अग्रणी शून्य जोड़ा जाता है। फिर, 0643 के रूप में पढ़ा जा सकता है: शून्य 6s, चार 3s, इसलिए आउटपुट 3333 होगा।

(यह OEIS A056967 है )।

कार्य: धनात्मक पूर्णांक की एक सरणी को देखते हुए, उन्हें उनके डिजिट-जोड़ी-वर्णित मान द्वारा, आरोही क्रम में क्रमबद्ध करें। आदेश इनपुट संख्याओं के बीच कोई फर्क नहीं पड़ता है जो समान मूल्य पर ले जाते हैं।

इनपुट : सकारात्मक पूर्णांक की एक सरणी / सूची / सेट। इनपुट में अग्रणी शून्य की अनुमति नहीं है , और अंकों / आदि के तार / सूचियों के रूप में इनपुट। की अनुमति नहीं है - इनपुट पूर्णांक / संख्यात्मक प्रकार के करीब होना चाहिए क्योंकि आपकी भाषा उपयोग करने में सक्षम है।

आउटपुट : उपर्युक्त तरीके से छांटे गए सरणी, सामान्य तरीकों में से किसी में लौटे (फ़ंक्शन रिटर्न वैल्यू / STDOUT / चिल्लाने में शून्य / आदि।) आप उन्हें व्यक्तिगत रूप से प्रिंट कर सकते हैं, उन्हें संख्याओं, स्ट्रिंग्स या सूचियों के रूप में वापस कर सकते हैं। अंक।

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

Input 
Output

[19, 91, 2345, 2023]
[19, 2023, 2345, 91]

[25257, 725, 91, 5219, 146125, 14620512]
[725, 5219, 14620512, 91, 146125, 25257]

[123130415 3335 91 111111111 528 88]
[528, 111111111, 123130415, 3335, 88, 91]

[1 21 33 4 5]
[1 4 5 21 33]

[3725, 10, 2537, 1, 1225, 2512]
[10, 1, 1225, 2512, 2537, 3725]

[125, 26, 1115, 1024] 
[1115, 1024, 125, 26]

(4 वें परीक्षण मामले में, 1, 4, और 5 सभी 0 का मूल्यांकन करते हैं, और इसलिए किसी भी क्रम में आपस में हल किया जा सकता है। इसी तरह पांचवें परीक्षण मामले में, 10 और 1 दोनों 0 मूल्यांकन करते हैं, और इसलिए इसे हल किया जा सकता है। या तो आदेश।)

(संबंधित: कहो कि तुम क्या देख रहे हो , वन १, टू १, वन २ वन १

सैंडबॉक्स में सवाल स्पष्ट करने में मदद के लिए केविन क्रूज़सेन का धन्यवाद।

Comments

क्या हम इनपुट के रूप में अंकों की सूची की सूची ले सकते हैं? क्या हम अंकों की सूची की सूची तैयार कर सकते हैं?

— श्री Xcoder

@ Mr.Xcoder इनपुट पूर्णांकों की सूची के रूप में होना चाहिए, अंकों की सूची नहीं। आउटपुट अंकों की सूचियों की एक सूची हो सकता है, अगर यह किसी भी तरह अधिक सुविधाजनक है।

— सूंदर -

जैसा कि @mnel द्वारा बताया गया है, मेरा उत्तर 10 अंकों से ऊपर के अंकों के लिए काम नहीं करेगा। क्या इसे वैसा ही रखना वैध है, या मुझे इसे 32 बाइट की कीमत पर संशोधित करना चाहिए।

— JayCe

@JayCe यदि मैं सही ढंग से समझूं, तो सीमा इसलिए है क्योंकि वह पूर्णांक प्रकार की सीमा R में है - क्योंकि strtoiपूर्णांक लौटाता है - सही? यदि हां, तो यह ठीक है, यह कानूनी है जैसा कि यह है।

— सूंदर -

तुम सही हो! जैसा है वैसा ही रखेगा।

— JayCe

Answer 1

एपीएल (डायलॉग) , 26 बाइट्स

1 बाइट बचाने के लिए धन्यवाद ngn :)

{⍵[⍋⌽↑,⍨⌿⍴⌿0 10⊤⍵⊤⍨⍴⍨100]}

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

प्रेरणा dima और ngn से लेते हैं

Comments

100⊥⍣¯1⊢⍵-> ⍵⊤⍨⍵/10026 के लिए काम करता है।

— jslip

मैं वास्तव में दिए गए परीक्षण मामलों पर WSFULLs नहीं चाहता

— H.PWiz

MAXWS = 1M

— ngn

100⊥⍣¯1⊢⍵->⍵⊤⍨⍴⍨100

— ngn

@ H.PWiz और यहां 26 बाइट्स के लिए एक अलग समाधान है:{⍵[⍋⌽↑,⍨⌿⍴⌿⊃⊥⍣¯1/10 100⍵]}

— ngn

Answer 2

आर , 141 बाइट्स

(s<-scan(,""))[order(strtoi(sapply(s,function(x)paste(strrep((m=matrix(c(if(nchar(x)%%2)0,el(strsplit(x,""))),2))[2,],m[1,]),collapse=""))))]

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

बल्कि श्रमसाध्य उत्तर - लेकिन यह सभी परीक्षण मामलों पर काम करता है। डिजिट-पेयर आउटपुट बनाता है और इसके अनुसार इनपुट को सॉर्ट करता है।

Comments

मैंने अपना जवाब एक और उत्तर पर पोस्ट किया क्योंकि मैं इस दोपहर को काम कर रहा था लेकिन मैं बाधित था। बस आपको यह विश्वास दिलाने के लिए कि मुझे आपकी प्रेरणा बिना क्रेडिट के नहीं मिली;)

— digEmAll

@digEmAll कोई चिंता नहीं है :) - वास्तव में मुझे लगता है कि मैंने vचर का नाम आपके अन्य उत्तरों से लिया है - मैंने vपहले कभी इस्तेमाल नहीं किया । और अच्छा उपयोग intToUtf8!

— JayCe

अहा मैं वास्तव में अपने एकल अक्षर चर नामों से ईर्ष्या कर रहा हूँ! नहीं, गंभीरता से ... StackOverflow से आने वाले हर बार मैं एक "समान" विकल्प पोस्ट करता हूं जो उसे चोरी की तरह लगता है;)

— digEmAll

स्ट्रैटो 10 अंकों से ऊपर पूर्णांक के लिए NA लौटेगा, (as.numeric will)

— mnel

@ बाहर इशारा करने के लिए धन्यवाद! मैंने sundar के साथ जाँच की और चूंकि यह पूर्णांक प्रकार की एक सीमा है जिसे मैं इसे छोड़ सकता हूं: :)

— JayCe

Answer 3

आर , 120 बाइट्स

(v=scan())[order(sapply(v,function(n,e=nchar(n))sum((a=rep((x=n%/%10^(0:(e-1-e%%2))%%10)[!0:1],x[!1:0]))*10^seq(a=a))))]

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

• -11 बाइट्स के लिए @sundar "अंकगणितीय" सुझाव के लिए धन्यवाद!

स्पष्टीकरण के साथ अघोषित कोड:

# define a function G which takes a number 'n' and uncompress it multiplied by 10
# e.g. 2735 -> 775550, 61345 -> 355550 etc.
G=function(n){
  e = nchar(n)                   # get the n.of digits in the compressed number

  x = n%/%10^(0:(e-1-e%%2))%%10  # split 'n' into vector of digits reversed adding 
                                 # trailing zero if 'e' is odd (e.g. 123 -> c(0,3,2,1))

  even = x[!0:1]                 # take only the odd elements of 'x' (= even digits)
  odd  = x[!1:0]                 # take only the even elements of 'x' (= odd digits)
                                 # N.B. :
                                 # these tricks work because !0:1 is c(TRUE,FALSE)
                                 # and V[c(TRUE,FALSE)] exploits the fact that R 
                                 # automatically recycles the logical indexes up to the
                                 # length of the vector V

  a = rep(even,odd)              # repeat each value in 'even' 'odd' times obtaining the
                                 # uncompressed number as digits vector. Note that in
                                 #  case of single digit 'n', 'a' will be an empty vector

  sum(a*10^seq(a=a))             # multiplies 'a' * 10^(1:length(a)) and sum 
                                 # obtaining the uncompressed number multiplied by 10
                                 # N.B. in case of empty 'a', we get 0
}

v = scan()                       # take vector v from stdin

w = sapply(v,G(n))               # apply G to all numbers of 'v'

v[order(w)]                      # use the uncompressed values as weights to sort 'v'

Comments

[!1:0]चाल असली अच्छा है - पहले कभी नहीं देखा।

— JayCe

@sundar: स्पष्टीकरण जोड़ा गया;)

— digEmAll

अच्छा लगा। मुझे पता था कि वे [!1:0]फाल्स कुछ साफ सुथरे थे। मैं इस के साथ खेल रहा था और आर गोल्फिंग की युक्तियों, अंक को अंक से अंकगणितीय रूप से (बिना as.double) प्राप्त करने की कोशिश कर रहा था , लेकिन केवल एक 132 बाइट संस्करण के साथ आया: TIO

— sundar - Reinstate Monica

@ सूंदर: मैं अंकगणितीय दृष्टिकोण के बारे में नहीं सोचता ... मैंने 11 बाइट्स बचाए, धन्यवाद!

— digEmAll

Answer 4

अजगर , 14 बाइट्स

oir9c.[Z2jNT2T

यहाँ यह कोशिश करो! | परीक्षण सूट! | अंकों की सूची के साथ 12 बाइट्स I / O

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

oir9c.[Z2jNT2T – Full program.
o              – Sort the input list by the results of the following code (variable: N).
         jNT   – Cast the current element to a list of digits.
     .[Z2      – Pad it on the left with 0s to the nearest multiple of 2.
    c       2  – Split in pieces of length 2.
  r9           – Run length decode.
 i           T – Cast the list of digits to a base 10 integer.

Answer 5

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

ṚẋƝm2ṚFḌµÞ

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

एक परीक्षण सूट की जाँच करें!

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

ṚẋƝm2 programFḌµÞ मोनाडिक लिंक / पूर्ण कार्यक्रम। | उदाहरण: [25257, 725, 91, 5219, 146125, 14620512]
        µÞ मोनडिक लिंक के परिणाम द्वारा इनपुट सूची को क्रमबद्ध करें: | उदाहरण: 725
Array एन को अपने अंक सरणी में बढ़ावा दें और इसे उल्टा करें। | [५, २, 7]
 ẋƝ प्रत्येक दो लगातार अंकों के लिए x, y, xy बार दोहराएं। | [[५, ५], [२, २, २, २, २, २, २]]
   एम 2 मॉड्यूलर 2. इस सरणी के हर दूसरे तत्व को लें। | [[५, ५]]
     Ṛ उल्टा। | [[५, ५]]
      एफ फ्लैटन। | [५, ५]
       To दशमलव से पूर्णांक में परिवर्तित करें। | 55

Comments

यह निश्चित रूप से एक संयोग है: 2537और 3725एक ही संख्या का प्रतिनिधित्व नहीं करते हैं।

— आउटगॉल्फ

क्या आप मुझे एक ऐसा टेस्ट केस दे सकते हैं जो उसे पकड़ ले, और मैं उसे सवाल में जोड़ दूंगा?

— सूंदर -

@sundar के रूप में एरिक ने कहा [2537, 3725]। मैंने कभी संदेह नहीं किया कि यह एक संयोग है, इसलिए मैंने उस नोट को उत्तर में शामिल किया

— श्री एक्सकोडर

@ Mr.Xcoder टेस्टकेस जोड़ा गया, धन्यवाद।

— सूंदर -

Answer 6

पर्ल 6 , 53 बाइट्स

*.sort(+*.flip.comb.rotor(2).map({[x] $_}).join.flip)

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

अनाम जो भी लंबोदर है जो मानों की एक सूची लेता है और संख्याओं के जोड़े का वर्णन करता है।

इस मामले में, मैं संख्या को उलट रहा हूं, फिर rotorप्रत्येक जोड़ी की संख्या प्राप्त करने के लिए सूची को दो से जोड़ दें। यह विषम लंबाई की संख्या के लिए पहले अंक को बाहर कर देगा, लेकिन चूंकि यह 0उस संख्या के बार में अनुवाद करता है , यह ठीक है। इसके अलावा, यह [x]सही ढंग से उपयोग करने के लिए मूल्यों को रेखाबद्ध करता है।

Answer 7

पायथन 2 , 80 74 बाइट्स

def g(l):l.sort(key=f)
f=lambda n:+(n>9)and int(`f(n/100)`+n/10%10*`n%10`)

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

Answer 8

हास्केल , 89 88 बाइट्स

ओट्स के लिए बाइट का धन्यवाद सहेजा

import Data.List
(%)=mod
m?n|n<1=0|n%100<10=m?div n 100|w<-n-10=m*10?w+m*n%10
sortOn(1?)

अंतिम पंक्ति एक अनाम फ़ंक्शन को परिभाषित करती है जिसका उपयोग इस तरह किया जा सकता है:

> sortOn(1?)[19, 91, 2345, 2023]
[19,2023,2345,91]

कोर कार्यक्षमता इन्फिक्स ऑपरेटर द्वारा प्रदान की जाती है (?)जो एक गुणक m, और शेष आरएलई इनपुट का ट्रैक रखता है n। (?)लगातार 10 से घटाना है, nजबकि से घटाना करने के लिए एक दसियों अंक है, और के रूप में यह ऐसा करता है तो यह अंतिम अंक की एक और प्रतिलिपि उत्पादन के सामने (गुणक के माध्यम से m, जो हर बार 10 से बढ़ जाती है) को धक्का देता है । जब दहाई का स्थान समाप्त हो जाता है, तो अंतिम दो अंक छोड़ दिए जाते हैं और जब तक संख्या 0. कम नहीं हो जाती है, तब तक प्रक्रिया दोहराती है। अंत में, हम ऑपरेटर (1 के प्रारंभिक गुणक के साथ) को सॉर्ट कुंजी के रूप में उपयोग करते हैं।

Comments

m?n|n<1=0|n%100<10=m?div n 100|w<-n-10=m*10?w+m*n%10एक बाइट छोटी है।

— ovs

Answer 9

भूसी , 10 बाइट्स

ÖödṁΓ*C_2d

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

व्याख्या

ÖödṁΓ*C_2d    Full function
Ö             Sort the input list by the result of...
 ö            The composition of these four functions:
         d      Convert to a list of digits
      C_2       Split into length-2 sublists starting at the end
   ṁ            Map the following function and concatenate the results:
    Γ*            Repeat the list tail X times, where X is the list head
  d             Convert back to an integer

Answer 10

डेलयॉग एपीएल, 41 39 36 35 31 30 29 बाइट्स

f←⊂⌷¨⍨∘⍋{10⊥∊⍴⌿0 10⊤100⊥⍣¯1⊢⍵}¨

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

-2 गायों के लिए धन्यवाद
-4 (आधार रूपांतरण विचार के लिए प्लस -4) ngn
-2 धन्यवाद इसलिए H.PWiz

Comments

⊃,/ बन सकता है ∊

— कृति लिथोस

@ मुझे पता है कि मैं एक अंतर्निहित पी भूल रहा था

— द्विजिमा

{⍺⍴⍨⍎⍵} -> ⍴⍨∘⍎

— ngn 18'18

@ निश्चित रूप से, मैं कभी भी सभी जोत / ट्रेन चीजों को याद नहीं कर सकता

— दिजिमा

यहाँ 1 बाइट के लिए एक और चाल है - के {⍵[⍋F ⍵]}रूप में प्रशिक्षित करें⊂⌷¨⍨∘⍋F

— ngn

Answer 11

सी (जीसीसी) (32 बिट सिस्टम), 188 177 176 बाइट्स

char*p,*q,c[99],b[99]="0";i;d(x){for(p=b+!(sprintf(b+1,"%d",x)&1),q=c;i=*p++;++p)for(i-=48;i--;*q++=*p);*q=0;atoi(c);}m(int*a,int*b){return d(*a)-d(*b);}s(l,c){qsort(l,c,4,m);}

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

पर amd64ऐड झंडा -m32संकलन के लिए।

उपयोग : s(x,n);जहां xसॉर्ट करने के लिए पूर्णांक की एक सरणी को इंगित करता है और nउस सरणी की लंबाई है।

दूसरा परीक्षण मामला गलत परिणाम देता है क्योंकि परिवर्तित करने 25257से 2222277777जो 32 बिट पूर्णांक को ओवरफ्लो करता है - उस संख्या के बिना 5 वां परीक्षण मामला जोड़ा गया।

स्पष्टीकरण:

char*p,                                     // d(): input pointer
    *q,                                     // d(): output pointer
    c[99],                                  // d(): output buffer
    b[99]="0";                              // d(): input buffer
                                            //      (fixed first char 0)
i;                                          // d(): repeat counter

d(x){                                       // conversion function
    for(
            p=b+!(sprintf(b+1,"%d",x)&1),   // print number in decimal to
                                            // input buffer, starting at second
                                            // character, initialize input
                                            // pointer to first or second char
                                            // depending on the length of the
                                            // number
            q=c;                            // initialize output pointer
            i=*p++;                         // set repeat counter to digit and
                                            // point to next digit, stop when
                                            // NUL character is found
            ++p)                            // point to next digit after loop
        for(i-=48;i--;*q++=*p);             // inner loop, append current digit
                                            // i-48 ('0') times to output buffer
    *q=0;                                   // terminate output with NUL
    atoi(c);                                // convert to number, 'return' not
                                            // needed as atoi() leaves result
                                            // on the stack
}

m(int*a,int*b){                             // comparison function for qsort
    return d(*a)-d(*b);                     // return difference of converted
}                                           // values

s(l,c){                                     // sorting function
    qsort(l,c,4,m);                         // only "wrap" qsort, assuming
}                                           // sizeof(int) is 4

Comments

आपका कार्य d()लंबे समय से है क्योंकि उनसे संबंधित तार और कार्य, आप पिछले 2 अंकों को पढ़कर और इस तरह से आउटपुट का निर्माण करके कई बाइट्स बचा सकते हैं: o;u;i;d(x){for(u=1,o=0;x;x/=100)for(i=0;i++<x%100/10;o+=x%10*u,u*=10);x=o;}m(int*a,int*b){u=d(*a)-d(*b);}s(l,c){qsort(l,c,4,m);}आप एस को घोषित करने और आरंभ करने से बचकर भी बाइट्स बचाएंगे char।

— Annyo

अच्छा विचार - मुझे लगता है कि पूर्णांक मानों पर काम करना इसे पूरी तरह से अलग दृष्टिकोण बनाता है, इसलिए आपको उत्तर पोस्ट करने पर विचार करना चाहिए? :)

— फेलिक्स पाम्स

b-~sprintf(b+1,"%d",x)%2इसके बजाय सुझाव देंb+!(sprintf(b+1,"%d",x)&1)

— छत

@Annyo के x/10%10बजाय सुझाव देते हैंx%100/10

— सीलिंगकैट

Answer 12

अजगर 2 , 102 101 97 101 बाइट्स

lambda l:sorted(l,key=lambda x:int(''.join(v*int(c)for c,v in zip(*[iter(`x`[len(`x`)%2:])]*2))or 0))

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

Comments

@ सूंदर कोई चिंता नहीं, तय

— TFeld

Answer 13

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

{↔ġ₂ẹ{Ċj₎|Ȯt}ˢ↔c}ᵒ

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

व्याख्या

तीन अलग-अलग मामलों के लिए आवश्यक छोटे सामानों का भार: विषम संख्याओं के अंक, 0 की संख्या में एक संख्या, और सामान्य जोड़े।

{               }ᵒ     Order the Input according to the output of this predicate
 ↔                       Reverse the number
  ġ₂                     Group into pairs; the last digit is alone if there are
                           an odd number of them
    ẹ{      }ˢ           For each group:
      Ċ                    If there are two elements
       j₎                  Juxtapose the first one as many times as the second
                             element (won't work if the second element is 0)
         |                 Else
          Ȯ                If there is one element (odd number of digits)
           t               just take that element
                           (Else don't select anything, i.e. 0 repetitions)
              ↔c         Reverse and concatenate back into an integer

Comments

मुझे लगता है कि |Ȯtयह अनावश्यक है, और वास्तव में यह इसे गलत बनाता है: यह 0 के बजाय 1 के साथ पैडिंग के बराबर है, इसलिए दिए गए [125, 26, 1] को 1 के बजाय [1, 26, 125] के रूप में टाइप करें। , १२५, २६]।

— सूंदर -

Answer 14

पर्ल 5 , 76 बाइट्स

एक बार के लिए एक लाइनर के बजाय एक फ़ंक्शन।

सीधे आगे आगे: संख्याओं को परिवर्तित करने के लिए g, इनपुट को संख्यात्मक रूप hसे क्रमबद्ध करें। hरेगेक्स का उपयोग करके ऐसा करता है s/(.)(.)/$2x$1/gre(जो संभवतः पर्याप्त पठनीय है)। और 0बाएं गद्दी साथ किया जाता है 0 x("@_"=~y///c%2)."@_"(जहां y///cलेखन की एक shorted तरीका है length, xपुनरावृत्ति ऑपरेटर और है .संयोजन)।

sub h{(0 x("@_"=~y///c%2)."@_")=~s/(.)(.)/$2x$1/gre}sub g{sort{h($a)-h$b}@_}

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

मैं हालांकि कुछ छोटे पर्ल जवाब देखने की उम्मीद कर रहा हूँ!

Answer 15

रेटिना , 44 बाइट्स

^.?((..)*)$
$1 $&
%)`\G(\d)(.)
$1*$2
N`
.+ 

इसे ऑनलाइन आज़माएं! लाइन की शुरुआत में सॉर्ट कुंजी बनाना कठिन है, लेकिन शॉर्ट सॉर्ट चरण के परिणामस्वरूप कुल 3 बाइट की बचत होती है। स्पष्टीकरण:

%)`

प्रत्येक पंक्ति में पहले दो चरणों को व्यक्तिगत रूप से लागू करें।

^.?((..)*)$
$1 $&

मिलान अंकों की सम संख्या को कॉपी और कॉपी करें।

\G(\d)(.)
$1*$2

प्रत्येक डिजिट जोड़ी को उनके वर्णित मूल्य से बदलें। \G\dअंतरिक्ष में मैच को रोकने का कारण बनता है।

N`

संख्यात्मक रूप से क्रमबद्ध करें।

.+ 

सॉर्ट कीज को डिलीट करें।

Comments

यह एक कुंजी द्वारा सॉर्ट करने के लिए एक चतुर चाल है। अच्छा था।

— सूंदर -

Answer 16

05AB1E , 20 19 बाइट्स

ΣDgÉi¦}2ôε`sиJ}J0ìï

बग को +1 बाइट के लिए तय किया गया, और फिर @sundar की बदौलत -2 बाइट्स के लिए गोल्फ बनाया गया ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

निश्चित रूप से गोल्फ हो सकता है .. इसके बारे में बहुत खुश नहीं tbh ..

स्पष्टीकरण:

Σ                    # Sort by:
 Dg                  #  Duplicate the current number, and take it's length
                     #   i.e. 25257 → 5
                     #   i.e. 4 → 1
   Éi }              #  If this length is odd:
     ¦               #   Remove the first digit
                     #    i.e. 25257 → '5257'
                     #    i.e. 4 → ''
       2ô            #  Then split the number in pieces of 2
                     #   i.e. '5257' → ['52','57']
                     #   i.e. '' → []
         ε    }      #  And map each to:
          `          #   Push both digits to the stack
                     #    i.e. '52' → '5' and '2'
           s         #   Swap them
            и        #   Repeat the first digit the second digit amount of times
                     #    i.e. '2' and '5' → ['2','2','2','2','2']
             J       #   Join the list of digits together
                     #    i.e. ['2','2','2','2','2'] → '22222'
               J     #  Join all numbers back together again
                     #   i.e. ['','22222','77777'] → '2222277777'
                     #   i.e. [] → ''
                0ì   #  Prepend a 0 (because `Σ` will put all '' at the back)
                     #   i.e. 2222277777 → '02222277777'
                     #   i.e. '' → '0'
                  ï  #  Cast it to an integer, because sorting is done string-wise by
                     #  default despite 05AB1E's interchangeability of strings and numbers;
                     #  and it's also to remove all leading zeros
                     #   i.e. '02222277777' → 2222277777
                     #   i.e. '0' → 0

Answer 17

अटैची , 50 बाइट्स

SortBy!N@Flip##~`&&>PadRight&0&2=>Chop&2@Flip@List

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

व्याख्या

SortBy!N@Flip##~`&&>PadRight&0&2=>Chop&2@Flip@List      anonymous function, argument: [a1..aN]
SortBy!                                                 sort the given array by grading f[ai]
                                                        e.g. 42513
                                              List      digits of ai
                                                        e.g. [4, 2, 5, 1, 3]
                                         Flip@          flip the digits around
                                                        e.g. [3, 1, 5, 2, 4]
                                  Chop&2@               chop into groups of 2
                                                        e.g. [[3, 1], [5, 2], [4]]
                    PadRight&0&2=>                      pad each group to size 2 with 0's
                                                        e.g. [[3, 1], [5, 2], [0, 4]]
                  &>                                    using each sub array as arguments...
               ~`&                                      ...repeat the 2nd the 1st amount of times
                                                        e.g. [[1, 1, 1], [2, 2, 2, 2, 2], []]
             ##                                         then:
         Flip                                           reverse the groups
                                                        e.g. [[2, 2, 2, 2, 2], [1, 1, 1]]
       N@                                               then convert it to an number
                                                        e.g. 22222111

Answer 18

जावास्क्रिप्ट (ईएस 8), 72 70 बाइट्स

a=>a.sort((a,b)=>(g=n=>n&&g(n/100|0)+''.padEnd(n/10%10,n%10))(a)-g(b))

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

Answer 19

जाप, 13 बाइट्स

ñ_ì_ò2n)®rçì

यह कोशिश करो या सभी परीक्षण मामलों को चलाएं

---

व्याख्या

ñ_                :Sort by passing each integer through a function
  ì_              :  Split to an array of digits, pass it through the following function and implicitly convert back to an integer
    ò2n)          :    Starting from the end of the array, split at every second element
        ®         :    Map
         rç       :      Reduce X & Y by repeating X Y times
           Ã      :    End mapping
            ¬     :    Join

Answer 20

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

DŻLḂ$¡ẋ@2/ẎḌµÞ

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

Answer 21

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

->a{a.sort_by{|a|s='';s,a=[a%10]*(a/10%10)*''+s,a/100while a>0;s.to_i}}

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

Answer 22

जावा 11, 204 189 बाइट्स

L->{L.sort((a,b)->Long.compare(s(a+""),s(b+"")));}long s(String s){var r="";for(int l=s.length(),i=l%2;i<l;)r+=s.split("")[++i].repeat(s.charAt(i++-1)-48);return r.isEmpty()?0:new Long(r);}

पैरामीटर के रूप में एक सूची की सूची लेता है और इस इनपुट-सूची (नई सूची को लौटाए बिना) को सॉर्ट करता है।

इसे ऑनलाइन आज़माएं (नोट:String.repeat(int) रूप में अनुकरण किया गया हैrepeat(String,int) इसलिए क्योंकि जावा 11 अभी तक TIO पर नहीं है। बाइट-काउंट समान है।)

स्पष्टीकरण:

L->{                     // Method with ArrayList<Long> parameter and no return-type
  L.sort(                //  Sort the list by:
   (a,b)->Long.compare(  //   Using a builtin Long-comparator with:
     s(a+""),s(b+"")));} //   The correctly formatted values as described in the challenge

long s(String s){        // Separated method with String parameter and long return-type
  var r="";              //  Temp-String, starting empty
  for(int l=s.length(),  //  The length of the input-String
      i=l%2;i<l;)        //   If the length is even:
                         //    Loop `i` in the range [0,`l`) (in steps of 2)
                         //   Else (the length is odd):
                         //    Loop `i` in the range [1,`l`) (in steps of 2) instead
    r+=                  //   Append the result-String with:
      s.split("")[++i].  //    The digit at index `i+1`
      .repeat(s.charAt(i++-1)-48);
                         //    Repeated the digit at index `i` amount of times
  return r.isEmpty()?    //  If the temp-String is empty:
          0              //   Return 0
         :               //  Else:
          new Long(r);}  //   Convert the temp-String to a long and return it

Comments

नमस्ते, चुनौती स्पष्ट रूप से स्ट्रिंग इनपुट को खारिज कर देती है, क्षमा करें! (मैं इसे जावा के लिए अनुमति देने के लिए लुभा रहा हूं, लेकिन यह अन्य उत्तरों पर उचित नहीं होगा।)

— सूंदर -

@sundar आह, उस आवश्यकता को याद किया; मेरा बुरा .. सौभाग्य से यह +""स्ट्रिंग को संख्या में परिवर्तित करने के लिए सिर्फ 2x में जोड़ने का एक आसान फिक्स है । अब तय होना चाहिए। :)

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

अच्छा लगा। मुझे उम्मीद नहीं थी कि जावा से। :)

— सूंदर - मोनिका