कई रंगों का कोट

22

चुनौती

इनपुट के रूप में अद्वितीय रंग नामों की एक सूची को देखते हुए , उन्हें इस क्रम में क्रमबद्ध करें कि वे पहली बार यूसुफ के कमाल टेक्नीकलर ड्रीमकोट में दिखाई दें ।

उदाहरण

Input:  green, blue, red, brown
Output: red, green, brown, blue

क्रम में रंगों की पूरी सूची है:

 1. red
 2. yellow
 3. green
 4. brown
 5. scarlet
 6. black
 7. ochre
 8. peach
 9. ruby
10. olive
11. violet
12. fawn
13. lilac
14. gold
15. chocolate
16. mauve
17. cream
18. crimson
19. silver
20. rose
21. azure
22. lemon
23. russet
24. grey
25. purple
26. white
27. pink
28. orange
29. blue

या तार की एक सरणी के रूप में:

["red","yellow","green","brown","scarlet","black","ochre","peach","ruby","olive","violet","fawn","lilac","gold","chocolate","mauve","cream","crimson","silver","rose","azure","lemon","russet","grey","purple","white","pink","orange","blue"]

नियम

  • जब तक यह हमारे मानक I / O नियमों द्वारा अनुमत है, तब तक आप किसी भी उचित, सुविधाजनक साधन (जैसे, स्ट्रिंग्स की एक सरणी, एक सीमांकित स्ट्रिंग, व्यक्तिगत स्ट्रिंग्स) द्वारा इनपुट ले सकते हैं , लेकिन कृपया अपने उत्तर में अपनी इनपुट विधि निर्दिष्ट करें।
  • आप अपने आउटपुट के लिए भी ऐसा कर सकते हैं।
  • इनपुट में केवल उपरोक्त सूची के रंग होंगे।
  • आपका समाधान खाली इनपुट को संभालने में सक्षम होना चाहिए।
  • आप चुन सकते हैं कि इनपुट के सभी शब्द लगातार अपरकेस, लोअरकेस या शीर्षक मामले हैं लेकिन आपके आउटपुट के आवरण को आपके इनपुट से मेल खाना चाहिए ।
  • यह प्रत्येक भाषा की जीत में कोड-गोल्फ इतनी कम बाइट गिनती है।
  • हमेशा की तरह, मानक कमियां निषिद्ध हैं।

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

Input:  []
Output: []

Input:  ["green", "blue", "red", "brown"]
Output: ["red", "green", "brown", "blue"]

Input:  ["gold", "grey", "green"]
Output: ["green", "gold", "grey"]

Input:  ["ruby","yellow","red","grey"]
Output: ["red", "yellow", "ruby", "grey"]

Input:  ["gold", "green", "fawn", "white", "azure", "rose", "black", "purple", "orange", "silver", "ruby", "blue", "lilac", "crimson", "pink", "cream", "lemon", "russet", "grey", "olive", "violet", "mauve", "chocolate", "yellow", "peach", "brown", "ochre", "scarlet", "red"]
Output: ["red", "yellow", "green", "brown", "scarlet", "black", "ochre", "peach", "ruby", "olive", "violet", "fawn", "lilac", "gold", "chocolate", "mauve", "cream", "crimson", "silver", "rose", "azure", "lemon", "russet", "grey", "purple", "white", "pink", "orange", "blue"]
code-golf  array-manipulation 
— झबरा
स्रोत
1
सैंडबॉक्स (यह विश्वास करना मुश्किल है कि यह 18 महीने से खराब है!)
— झबरा

जवाबों:

11

पावरशेल , 262 155 151 127 125 125 बाइट्स

$args|sort{"rlyegwbrscbrocpyrvo lvnfaldgccvmacmcvseraolsrygpptwkpnoeb".indexof((-join$_[3,0]))}

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

भोला दृष्टिकोण। PowerShell sort-objectएक स्क्रिप्ट ब्लॉक के आधार पर सॉर्ट कर सकता है जो हर ऑब्जेक्ट के लिए निष्पादित होता है। यहाँ हम .IndexOf()रंग को एक स्ट्रिंग से प्राप्त कर रहे हैं , जो प्रत्येक रंग को एक संख्यात्मक मान प्रदान करेगा, और फिर उन संख्याओं के आधार पर छाँटेगा। अद्वितीयता सुनिश्चित करने के लिए प्रत्येक रंग के चौथे और पहले अक्षर से स्ट्रिंग का निर्माण किया जाता है। आउटपुट निहित है।

-4 बाइट्स शैगी को धन्यवाद।
-2 बाइट्स mazzy के लिए धन्यवाद।
केगलसियर को धन्यवाद -30 बाइट्स।

— AdmBorkBork
स्रोत
मुझे नहीं पता कि क्या आप इसे कुशलतापूर्वक (बाइट-वार) कर सकते हैं, लेकिन यदि आप लंबाई 3 सबस्ट्रिंग के आधार पर छाँटते हैं और फिर मूल स्ट्रिंग की द्वितीयक कुंजी के साथ सॉर्ट करते हैं, तो एकमात्र टक्कर वह है green greyजो सही वर्णमाला क्रम में है।
— हाइपरएन्यूट्रीनो
2
@ शैगी हाँ, वह काम करता है क्योंकि स्ट्रिंग नहीं मिलने पर .IndexOf()वापस आ जाएगी -1, जो redसही क्रम में है। धन्यवाद!
— AdmBorkBork
मुझे लगता है कि आप एक स्ट्रिंग के आसपास कोष्ठक हटा सकते हैं।
— मज़्ज़ी
@mazzy वास्तव में, धन्यवाद!
— AdmBorkBork
1
@Klasier वाह, उस स्ट्रिंग को खोजने के लिए धन्यवाद! यह बहुत बाइट्स बचाता है।
— AdmBorkBork
8

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

"जब संदेह है, तो बस खूनी इनपुट हैश।"

a=>a.sort((a,b)=>(g=s=>'i0008bar5dj60007f3001p09mseqg0hk40cnl2o'[parseInt(s,36)*50%257%170%40])(a)>g(b))

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

— Arnauld
स्रोत
मैंने पहले भी इस तरह हैश-आधारित समाधानों को देखा (और प्रभावित हुआ है)। क्या मैजिक स्ट्रिंग / मल्टीप्लायर / मॉड वैल्यूज़ उत्पन्न होते हैं, इसके लिए कहीं भी स्पष्टीकरण है? क्या यह केवल क्रूर बल है जब तक कि आप मूल्यों का एक सेट नहीं पाते हैं जो प्रत्येक संभावित रंगीन इनपुट के लिए एक अद्वितीय आउटपुट देता है, या एक अधिक चतुर दृष्टिकोण है?
— जैक ब्रूनस्टीन
1
@JackBrounstein यह एक त्वरित और गंदे जानवर बल की खोज थी जो यादृच्छिक मूल्यों की कोशिश कर रही थी और पूरी श्रृंखला की लंबाई को ध्यान में रखते हुए केवल अधिकतम आउटपुट (अंतिम मोडुलो के बाद) को कम कर रही थी (जैसे %99%55कि %123%55इस दृष्टिकोण के साथ बेहतर नहीं है )। तो यह निश्चित रूप से उप-इष्टतम है। मैं बाद में थोड़ा और अधिक परिष्कृत करने की कोशिश कर सकता हूं।
— अरनौलड
6

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

“½Ṗ©cƘʂẒẹMMỤẓHP’Œ?“ðÑþQ’,ḥµÞ

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

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

µअपनी बाईं ओर सब कुछ एक मुद्रीक श्रृंखला में बदल देता है, जो Þइनपुट सरणी पर मैप करता है और उत्पन्न मानों के अनुसार इनपुट को सॉर्ट करता है।

“½Ṗ©cƘʂẒẹMMỤẓHP’ रिटर्न मूल्य 176073885534954276199526358143331 पर सेट करता है।

Œ?[20,28,15,3,5,26,18,16,8,30,4,25,2,21,22,11,24,1,23,10,29,12,17,27,14,9,6,13,7,19]

“ðÑþQ’पैदावार 391695582; ,यह क्रमपरिवर्तन के लिए प्रस्तुत करता है। फिर, ḥc ompute Jelly का 391695582 वें हैश फंक्शन, जिसके परिणामस्वरूप बकेट्स को क्रमपरिवर्तन के पूर्णांक में मैप किया जाता है।

मैजिक निरंतर 391695582 जेली के बर्तनों द्वारा पाया गया था ।

dennis-home:utils$ time ./findhash 30 29 <<< '["red","yellow","green","brown","scarlet","black","ochre","peach","ruby","olive","violet","fawn","lilac","gold","chocolate","mauve","cream","crimson","silver","rose","azure","lemon","russet","grey","purple","white","pink","orange","blue"]'
391695582

real    0m2.058s
user    0m15.077s
sys     0m0.023s
— डेनिस
स्रोत
1
353690280752 29 बाल्टी में 29 रंगों को धोता है, लेकिन सांकेतिक शब्दों में बदलना करने के लिए एक और बाइट लेता है। अपरकेस (332849952364) या शीर्षक (862442225888) का उपयोग करना भी 28 बाइट्स पर निकलता है।
— डेनिस
5

पायथन 3 , 93 बाइट्स

lambda r:sorted(r,key=lambda s:'iV^ZzwnFM@pYuOobXGAKyf[tUR]E'.find(chr(int(s,36)%127%60+64)))

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

प्रत्येक रंग को आधार -36 के रूप में पढ़ता है int। ब्रूट को मजबूर किया और 19 में से एक मनमाना ऑफसेट चुना जिसे भागने की आवश्यकता नहीं थी।

— attinat
स्रोत
4

पॉवर्सशेल, 124 120 124 119 118 102 बाइट्स

$args|sort{$c=$_
'bluOrPiWPuG*yRusLeARoSiCriCrMCGoLFVOlRuPOBlSBGYR'-csplit'(?=[A-Z])'|%{$c-like"$_*"}}

यह ऑनलाइन की कोशिश करो!

स्पष्टीकरण:

  1. डेटा स्ट्रिंग में अवरोही क्रम में रंगीन लेबल के पहले महत्वपूर्ण अक्षर हैं। Greyलेबल को छोड़कर - G*yछोटा है।

  2. -csplit'(?=[A-Z])' सरणी में डेटा स्ट्रिंग को विभाजित करता है (blu,Or,Pi,W,Pu,G*y,Rus,Le,A,Ro,Si,Cri,Cr,M,C,Go,L,F,V,Ol,Ru,P,O,Bl,S,B,G,Y,R)

  3. |%{$c-like"$_*"}बूलियन की सरणी के लिए स्ट्रिंग सरणी को मैप करता है। जहां Trueइसका अर्थ है "इस स्ट्रिंग से एक रंग लेबल शुरू होता है" (जैसे केस-असंवेदनशील ऑपरेटर, csplit - केस-सेंसिटिव है। डॉक देखें )।

  4. sort{}आरोही क्रम में बूलियन के सरणियों द्वारा एक रंग लैब्स को सॉर्ट करें ।

सरणी द्वारा छँटाई Powershell में एक बहुत ही दिलचस्प विशेषता है। इस स्क्रिप्ट में सभी सरणियों की लंबाई समान है और केवल बूलियन मान हैं। यह छंटाई बूलियन सरणियों के लेक्सोग्राफिक क्रम में की जाती है।

इसलिए, स्ट्रिंग में अंतिम लेबल्स के लिए एक-अक्षर का संक्षिप्तीकरण हो सकता है। अगर सरणी की शुरुआत में मैच होता है, तो अंत में होने वाले मैचों का कोई प्रभाव नहीं पड़ता है।

       blu Or Pi W Pu G*y Rus Le A Ro Si Cri Cr M C Go L F V Ol Ru P O Bl S B G Y R
green: -   -  -  - -  -   -   -  - -  -  -   -  - - -  - - - -  -  - - -  - - T - -
gold : -   -  -  - -  -   -   -  - -  -  -   -  - - T  - - - -  -  - - -  - - T - -
grey : -   -  -  - -  T   -   -  - -  -  -   -  - - -  - - - -  -  - - -  - - T - -

     : green < gold < grey

कहाँ Tहै trueऔर -है false।

टेस्ट स्क्रिप्ट:

$f = {

$args|sort{$c=$_
'bluOrPiWPuG*yRusLeARoSiCriCrMCGoLFVOlRuPOBlSBGYR'-csplit'(?=[A-Z])'|%{$c-like"$_*"}}

}

@(
    ,( @(), @() )
    ,( ('green', 'blue', 'red', 'brown'), ('red', 'green', 'brown', 'blue') )
    ,( ("gold", "grey", "green"), ("green", "gold", "grey") )
    ,( ("ruby","yellow","red","grey"), ("red", "yellow", "ruby", "grey") )
    ,( ("gold", "green", "fawn", "white", "azure", "rose", "black", "purple", "orange", "silver", "ruby", "blue", "lilac", "crimson", "pink", "cream", "lemon", "russet", "grey", "olive", "violet", "mauve", "chocolate", "yellow", "peach", "brown", "ochre", "scarlet", "red"),
       ("red", "yellow", "green", "brown", "scarlet", "black", "ochre", "peach", "ruby", "olive", "violet", "fawn", "lilac", "gold", "chocolate", "mauve", "cream", "crimson", "silver", "rose", "azure", "lemon", "russet", "grey", "purple", "white", "pink", "orange", "blue") )
) | % {
    $inp,$expected = $_
    $result = &$f @inp  # splatting
    "$("$result"-eq"$expected"): $result"
}

आउटपुट:

True:
True: red green brown blue
True: green gold grey
True: red yellow ruby grey
True: red yellow green brown scarlet black ochre peach ruby olive violet fawn lilac gold chocolate mauve cream crimson silver rose azure lemon
russet grey purple white pink orange blue
— Mazzy
स्रोत
मेरे पास This site can’t be reachedत्रुटि है। माफ़ कीजिये।
— mazzy
1
आपके लिए एक संशोधित TIO जोड़ा गया।
— झबरा
1
मैंने आज TIO के लिए एक नया IP प्राप्त करने में कामयाबी हासिल की है। क्या यह अभी भी आपके लिए अवरुद्ध है?
— डेनिस
यह जिंदा है!!! ठंडा! और धन्यवाद!
— 20
3

मैं थोड़ी देर में स्ट्रिंग संपीड़न में सुधार करूंगा

जाप , 88 78 71 बाइट्स

ñ@`䊐âwrÒ.cÖ¨acru½ivo¤faØngoÒqauvœamsolv€osz¨e¶s gœrpl–tpˆ„g½u`bXé4 ¯3

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

— लुइस फेलिप डी जीसस मुनोज
स्रोत
यदि आप इसके लिए प्रयास करना चाहते हैं, तो अन्य समाधानों में से एक का त्वरित पोर्ट 46 बाइट्स में आता है।
— झबरा
@ शैगी मुझे नहीं लगता कि वे अब इसके लिए प्रयास कर रहे हैं: P
— ASCII-only
3

वोल्फ्राम भाषा 255 213 199 बाइट्स

डेनिस द्वारा बचाए गए चौदह बाइट्स, जो "निशान से बचते थे, तार के बजाय प्रतीकों का उपयोग करते थे।

SortBy[#,{yellow,green,brown,scarlet,black,ochre,peach,ruby,olive,violet,fawn,lilac,gold,chocolate,mauve,cream,crimson,silver,rose,azure,lemon,russet,grey,purple,white,pink,orange,blue}~Position~#&]&

यह ऑनलाइन की कोशिश करो!

— DavidC
स्रोत
2

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

lambda a:[y for x,y in sorted((max(" y gree br sc bla oc pe rub ol v f li go ch m cre cri si ro a le rus grey pu w pi or blu ".find(" %s "%c[:i+1])for i,j in enumerate(c)),c)for c in a)]

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

पहचानकर्ता स्ट्रिंग में प्रगतिशील चरित्र सबस्ट्रिंग (Ex: "ग्रीन" "g", "gr", "gre", "gree", और "green") के लिए सभी मिलानों को ढूँढता है और अधिकतम सूचकांक रखता है। "लाल" हमेशा सबसे पहले होता है, एफ़ फाइंड () लापता मैचों के लिए -1 देता है, इसलिए विशेष रूप से लाल के लिए कोई पहचानकर्ता नहीं है।

एक बार जब रंग (अनुक्रमणिका, रंग) जोड़े में बदल जाते हैं, तो जोड़ी के पहले आइटम पर सरणी को सॉर्ट करते हैं और फिर प्रत्येक जोड़ी के पहले आइटम को छोड़ देते हैं।

— Triggernometry
स्रोत
2

पायथन 3 , 130 बाइट्स

lambda*a:sorted(a,key=lambda c:("r,ylgebwsrtbcorpcryovvlfnlagdccamvca cmnsvrearlorsgyppwtpkonbe".find(c[::3]+" "*(c=="cream")),c))

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

— HyperNeutrino
स्रोत
@ शैगी मुझे ऐसा नहीं लगता? क्या आप मुझे एक इनपुट और इच्छित आउटपुट दे सकते हैं
— हाइपरएनुट्रिनो
@AdmBorkBork धन्यवाद, बस एहसास हुआ कि झबरा का क्या मतलब है। मैं केवल हरे और ग्रे की एक दूसरे से तुलना कर रहा था
— हायपरनीट्रीनो
शैगी और AdmBorkBork की टिप्पणियों में जोड़ने के लिए, "ग्रीन" और "ग्रे" दोनों "gre" से शुरू होते हैं।
— डेविड डे
@ शागि तय मुझे लगता है
— हायपरनेट्रिनो
1
@ शैगी ने इसे निश्चित किया, धन्यवाद। चॉकलेट caके ccaलिए एक विकल्प है क्योंकि क्रीम के लिए हैक का एक सा आवश्यक है ।
— हाइपरन्यूट्रिनो
2

सी # (विज़ुअल सी # इंटरएक्टिव कंपाइलर) , 321 219 210 161 159 138 बाइट्स

n=>n.OrderBy(a=>a!="grey"?"yelgrebroscablaochperuboliviofawlilgolchomaucrecrisilrosazulemruspurwhipinorablu".IndexOf(a.Substring(0,3)):65)

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

-3 बाइट्स शुगी के लिए धन्यवाद, -18 थेटलकोडर के लिए धन्यवाद

एक के रूप में इनपुट लेता है List<string>, एक रिटर्न देता हैIOrderedEnumerable<string>

यह कैसे काम करता है यह मूल स्ट्रिंग में प्रत्येक स्ट्रिंग के सूचकांक द्वारा सूची का आदेश देता है। मूल स्ट्रिंग में ग्रे रंग को छोड़कर हर रंग है, यह पहले तीन अक्षरों में बदल गया है। ग्रे वहाँ नहीं है, क्योंकि हरे और ग्रे अस्पष्टता का कारण बनेंगे। लाल या तो वहाँ नहीं है, क्योंकि IndexOfरिटर्न -1 अगर स्ट्रिंग दिखाई नहीं देता है।

इनपुट के रूप में IOrderedEnumerable लेने वाला छोटा संस्करण, 137 बाइट्स

n=>n.ThenBy(a=>a!="grey"?"yelgrebroscablaochperuboliviofawlilgolchomaucrecrisilrosazulemruspurwhipinorablu".IndexOf(a.Substring(0,3)):65)

इस तथ्य का लाभ उठाता है कि ThenBy1 बाइट से कम है OrderBy, लेकिन ThenByकेवल IOrderedEnumerableएस पर काम करता है ।

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

— अज्ञान का अवतार
स्रोत
मैं लगता है कि आप निकाल सकते हैं redआपके देखने स्ट्रिंग से और की जगह 68के साथ 65करने के लिए 3 को बचाने बाइट्स। मेरे फोन पर तो यह पूरी तरह से परीक्षण नहीं किया है।
— झबरा
आप 142 बाइट्स के लिए एक अंतर्निहित रिटर्न के साथ स्ट्रिंग इनलाइन का उपयोग कर सकते हैं n=>n.OrderBy(a=>a!="grey"?"redyelgrebroscablaochperuboliviofawlilgolchomaucrecrisilrosazulemruspurwhipinorablu".IndexOf(a.Substring(0,3)):68);हालांकि, आपको usingअपनी बाइट गिनती में एस शामिल करने की आवश्यकता है क्योंकि उन्हें चलाने की आवश्यकता होती है। यद्यपि आवश्यक गणना को छोटा करने के लिए आप नेमस्पेस ट्रिक का उपयोग कर सकते हैं ।
— द लीथल कोडर
यदि मैं नेमस्पेस ट्रिक का उपयोग करता हूं, तो क्या मुझे अपने नंबर के बाइट में नेमस्पेस को जोड़ना होगा?
— अज्ञानता
मैं सिर्फ विजुअल C # इंटरएक्टिव कंपाइलर में कंपाइलर बदल सकता हूं, और फिर मुझे यूजर्स नहीं जोड़ना होगा
— इग्नोरेंस का अवतार
आह इंटरएक्टिव में बदलने पर अच्छा विचार है, लेकिन हां अगर आपने नाम स्थान की चाल की तो आपको इसे अपनी बाइट की गिनती में शामिल करना होगा। अनिवार्य रूप से जोड़ना namespace System.Linq{}या जो भी आपने चुना होगा।
— TheLethalCoder
1

चारकोल , 69 68 63 56 बाइट्स

Ｆ⪪”E$↥l∧_∧K⁰ＲY⸿h⊕ψVG⌕gbＷ⟧⁼″5/²H✳<◨Ａ³?ω↗⊘‴⭆1”²Φθ№κ⎇Σιlilι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｆ⪪”E$↥l∧_∧K⁰ＲY⸿h⊕ψVG⌕gbＷ⟧⁼″5/²H✳<◨Ａ³?ω↗⊘‴⭆1”²

edyeeebrscckhrpeubivvifa99gohomaamrisiosazemuseypuwhpiorluलंबाई 2 के प्रत्येक विकल्प पर संपीड़ित स्ट्रिंग और लूप लें ।

Φθ№κ⎇Σιlilι

प्रत्येक सबस्ट्रिंग के लिए उन इनपुट स्ट्रिंग्स को प्रिंट करें जिनमें वह सबस्ट्रिंग होता है, जब तक कि सबस्ट्रिंग नहीं होता है 99, जिस स्थिति में lilइसके बजाय देखो । ( lilacकेवल रंग है कि एक अद्वितीय दो अक्षर का सबस्ट्रिंग नहीं है; oliveशामिल li; silverशामिल ilऔर blackभी शामिल है lac। fawnऔर azureसिर्फ एक पत्र का उपयोग कर पता लगाया जा सकता है, लेकिन वह यहाँ मदद नहीं करता है।)

— नील
स्रोत
1

पायथ, 66 बाइट्स

oxc."ayÇæ£ðÐ¥~@iF[2BÍÐ:Yë)^ksTTã"2s@LN,03

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

सूची में रंगों को विशिष्ट रूप से सूचकांक में ले जाकर 0और 3मॉड्यूलर इंडेक्सिंग मानकर पहचाना जा सकता है । इसके परिणामस्वरूप निम्न मैपिंग होती है:

rr -> red
yl -> yellow
ge -> green
bw -> brown
sr -> scarlet
bc -> black
or -> ochre
pc -> peach
ry -> ruby
ov -> olive
vl -> violet
fn -> fawn
la -> lilac
gd -> gold
cc -> chocolate
mv -> mauve
ca -> cream
cm -> crimson
sv -> silver
re -> rose
ar -> azure
lo -> lemon
rs -> russet
gy -> grey
pp -> purple
wt -> white
pk -> pink
on -> orange
be -> blue

पूर्ण विवरण:

oxc."..."2s@LN,03Q   Implicit: Q=eval(input())
                     Trailing Q inferred, dictionary string replaced with ... for brevity
o                Q   Order the elements of Q, as N, using:
              ,03      [0,3]
           @LN         Get the characters at the above indices in N
          s            Concatenate into a string
                         The above is result {1}
   ."..."              The compressed dictionary string
  c      2             Split into chunks of length 2
 x                     Get the index of {1} in the above
                       Implicit print of sorted list
— सोक
स्रोत
1

05AB1E , 48 बाइट्स

Σ.•Aå₂мÕh∊þèmvƶ\kΛ1YŠíJ>J#θ₁2©€,Ù{η¦ù-•2ôy¬s3è«k

अधिकांश अन्य उत्तरों के समान समाधान। बाद में इसे यहाँ से नीचे गिराने की कोशिश करेंगे।

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

स्पष्टीकरण:

Σ          # Sort the (implicit) input-list by:
 .•Aå₂мÕh∊þèmvƶ\kΛ1YŠíJ>J#θ₁2©€,Ù{η¦ù-•
           #  Push compressed string "rrylgebwsrbcorpcryovvlfnlagdccmvcacmsvrearlorsgyppwtpkonbe"
  2ô       #  Split into parts of size 2
 y         #  Push the current string of the list we're sorting
  ¬        #  Push its head (without popping)
   s       #  Swap so the string is at the top of the stack again
    3è     #  Get the character at index 3 (with automatic wraparound)
      «    #  Merge both characters together
       k   #  And get the index in the compressed string to sort on

इस 05AB1E टिप को देखें (अनुभाग कैसे डिक्शनरी के भाग को संपीड़ित नहीं करना है? ) यह समझने के लिए कि कैसा .•Aå₂мÕh∊þèmvƶ\kΛ1YŠíJ>J#θ₁2©€,Ù{η¦ù-•है "rrylgebwsrbcorpcryovvlfnlagdccmvcacmsvrearlorsgyppwtpkonbe"।

— केविन क्रूज़सेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.