पोस्ट-निर्धारित ऐरे सॉर्टिंग

Question

इनपुट:

• एक सरणी तीन पूर्णांकों युक्त 0, 1और 2किसी भी क्रम में (यानी [2, 0, 1])
• और लंबाई की एक स्ट्रिंग> = 2 जिसमें केवल वर्णमाला अक्षर होते हैं (दोनों निचले- और अपरकेस) और अंक (यानी a1B2c3)

आउटपुट:

सरणी के आधार पर हम स्ट्रिंग को सॉर्ट और आउटपुट करते हैं।
यह कैसे काम करता है?

• व्यूह a-z, A-Zऔर 0-9, प्रथम होने के क्रम को दर्शाता है 0; दूसरा होना 1; और तीसरा जा रहा है 2।
• स्ट्रिंग के व्यक्तिगत वर्णों को फिर उसी के आधार पर आदेश दिया जा सकता है।

उदाहरण:

• सरणी: [2, 0, 1]
• स्ट्रिंग: a1B2c3

सरणी के आधार पर, हम जानते हैं कि हमारा आदेश पूर्वता है 0-9a-zA-Z।
उसके आधार पर, हम स्ट्रिंग को परिवर्तित और आउटपुट कर सकते हैं 123acB:।

चुनौती नियम:

• सरणी के लिए आप 0-अनुक्रमित या 1-अनुक्रमित इनपुट का उपयोग करना चुन सकते हैं, इसलिए [3, 1, 2]यदि आप 1-अनुक्रमित सरणियों का उपयोग करना चाहते हैं , तो भी एक वैध इनपुट है।
• स्ट्रिंग (इनपुट और आउटपुट दोनों) में केवल मान्य वर्ण हैं abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:।
• अपनी भाषा सरणियों का समर्थन नहीं करता (या यदि आप के लिए चुनते हैं), तो आपको पहले पैरामीटर (यानी के लिए सरणियों के बजाय तार का उपयोग करने के लिए स्वतंत्र हैं 012, [0,1,2], आदि)।

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

• यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
  कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
• मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
• डिफ़ॉल्ट ढीले निषिद्ध हैं।
• यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
• इसके अलावा, यदि आवश्यक हो तो एक स्पष्टीकरण जोड़ें।

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

[2, 0, 1]  &  a1B2c3             ->   123acB
[2, 1, 0]  &  aAaA909UuHWw9gh2   ->   02999AAHUWaaghuw
[2, 1, 0]  &  6Bx43              ->   346Bx
[1, 0, 2]  &  jfjf33g            ->   ffgjj33
[0, 2, 1]  &  AbC13              ->   b13AC
[1, 2, 0]  &  Qfl0l              ->   Q0fll
[0, 1, 2]  &  9870abcABC         ->   abcABC0789
[0, 2, 1]  &  test123            ->   estt123
[2, 0, 1]  &  WHAT               ->   AHTW
[2, 0, 1]  &  WhAt               ->   htAW
[1, 0, 2]  &  102BACbac          ->   ABCabc012

Comments

"123"पहले पैरामीटर के लिए एक मान्य प्रारूप होगा ?

— Mego

संबंधित: एक आदेश का

— अनुकरण करें

@Mego हाँ क्यों नहीं। यह चुनौती के मुख्य भाग को प्रभावित नहीं कर रहा है। मैंने परिवर्तन को प्रतिबिंबित करने के लिए अपना प्रश्न संपादित किया है। उपयोग करने के लिए स्वतंत्र महसूस 123, 012, [0,1,2], [0, 1, 2], 0;1;2या जो भी आप पसंद करते हैं।

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

Answer 1

05AB1E , 15 14 12 बाइट्स

कोड:

v²žK26ôyèÃ{?

स्पष्टीकरण:

v             # For each in the input array.
  žK          #   Push a-zA-Z0-9.
    26ô       #   Split into pieces of 26.
       yè     #   Get the element-th element of the array.
 ²       Ã    #   Keep the characters of that element from the second input.
          {?  #   Sort pop and print without a newline.

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

Comments

इसके बजाए हटाने ²और उपयोग करके अब 10 बाइट्स हो सकते हैं । ₂26

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

Answer 2

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

lambda s,k:`sorted(s,key=lambda c:`k.index(3-ord(c)/32)`+c)`[2::5]

Ideone पर इसका परीक्षण करें ।

Answer 3

जावास्क्रिप्ट (ईएस 6), 87 बाइट्स

(a,s)=>a.map(n=>[...s].sort().join``.replace([/[^a-z]/g,/[^A-Z]/g,/\D/g][n],``)).join``

यदि इनपुट ऐरे ने आदेश दिया, तो पूर्ववर्ती के बजाय, तीनों श्रेणियों का (यह केवल एक फर्क पड़ता है [1, 2, 0]और [2, 1, 0]जिनके प्रभावों की अदला-बदली की जाती है) तो यह 80 बाइट्स के लिए काम करेगा:

(a,s,o=c=>a[(c<'a')+(c<'A')])=>[...s].sort((a,b)=>o(a)-o(b)||(a>b)-(a<b)).join``

मैंने इस सवाल को गलत बताया और अभी भी इसके साथ 7 उत्थान हुए हैं। अपने उत्थान को दूर करने के लिए स्वतंत्र महसूस करें और इसके बजाय @CharlieWynn को दें, जो मेरे दृष्टिकोण के लिए सबसे अच्छा सुधार लेकर आए।

(a,s)=>a.map(n=>s.replace([/[^a-z]/g,/[^A-Z]/g,/\D/g][n],``)).join``

Comments

ओह, बहुत दिलचस्प समाधान! मैं Array.sortवैकल्पिक फ़ंक्शन पैरामीटर का उपयोग करने के लिए एक अलग ES6 उत्तर के बारे में सोच रहा था, लेकिन यह इस तरह से बेहतर है।

— 8:15 बजे जुलूस

मैं वास्तव में इस समाधान को पसंद करता हूं, लेकिन मुझे लगता है कि यह परीक्षण 2, 3 और शायद अन्य को विफल करता है। मुझे लगता है कि आप तीन खंडों में से प्रत्येक को क्रमबद्ध करने वाले हैं?

— चार्ली व्यान

@CharlieWynn क्षमा करें, मुझे प्रश्न को गलत समझना चाहिए था। (यह मेरी एक आम गलती है।)

— नील

@ नहीं, मुझे नहीं लगता कि इस सवाल ने इस सरणी को छांटना बहुत स्पष्ट कर दिया है, बस देखा कि परीक्षण के मामलों में यह विशेषता है।

— चार्ली व्यान

@CharlieWynn अधिकांश परीक्षण मामलों में पहले से ही कम / ऊपरी / संख्यात्मक भागों को छांटा गया प्रतीत होता है ...

— नील

Answer 4

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

2_ịØWs26¤Ff@€

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

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

2_ịØWs26¤Ff@€  Main link. Arguments: k (permutation of [0, 1, 2]), s (string)

2_             Subtract the integers in k from 2, mapping [0, 1, 2] -> [2, 1, 0].
        ¤      Combine the three links to the left into a niladic chain.
   ØW          Yield the string following string.
               'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_'
     s26       Split it into chunks of 26 chars, i.e., ['A...Z', 'a...z', '0...9'].
  ị            Retrieve the chunks from the right result at the indices of the
               left result. The indices of the chunks are modular and 1-based;
               1 retrieves 'A...Z', 2 retrieves 'a...z', and 3 retrieves '0...9'.
         F     Flatten the resulting array of strings.
          f@€  Filter (swapped, each); for each character in the constructed
               string, select all occurrences of that character from s.

Answer 5

पायथ, 17 16 15 बाइट्स

s@RSz@L[GrG1`UT

परीक्षण सूट।

       [          array literal containing...
        G           the alphabet (lowercase)
         rG1        the alphabet, converted to uppercase
            `UT     inspect-range-10, generating the range [0,10) and
                      stringifying it, resulting in a string that contains no
                      letters and all numbers (so equivalent to '0123456789' for
                      filtering)
                    this creates ['ab...z', 'AB...Z', '01...9']

     @L           map over first (implicit) input (the ordering array) and take
                   the nth element in this array for each item
                   this gives us ['01...9', 'ab...z', 'AB...Z']

   Sz             take another line of input as a string and sort it, and then...
 @R               map over intersection: filter the line of input over presence
                    in each element in the new array
                    this results in ['123', 'ac', 'B']

s                 concatenate all and implicitly output

एक बाइट के लिए @FryAmTheEggman और दूसरे के लिए @Jakube का धन्यवाद !

Comments

आप उपयोग कर सकते हैं 'UTके बजाय s'MT।

— जुलुब

@ जाकुब मैं एक बैकटेक का उपयोग कर रहा हूं, एक भी बोली नहीं। लेकिन 'UTएक त्रुटि है, और `UTएक ही स्ट्रिंग में परिणाम नहीं करता है।

— दरवाज़े

हां, मेरा मतलब बैकटीक था। लेकिन टिप्पणियों में लिखना मुश्किल है। हां, यह एक अलग स्ट्रिंग उत्पन्न करता है, लेकिन यह कोई फर्क नहीं पड़ता। उत्पन्न स्ट्रिंग में सभी अंक और कोई अक्षर नहीं हैं।

— जुलुब १४'१६ को

@ जकुब ओह, मैं देख रहा हूं। यह चालाकी है; धन्यवाद!

— दरवाज़े

Answer 6

जावास्क्रिप्ट es6 77 बाइट्स

(a,s)=>a.map(o=>s.match([/[a-z]?/g,/[A-Z]?/g,/\d?/g][o]).sort().join``).join``

---

//test
f=(a,s)=>a.map(o=>(s.match([/[a-z]/g,/[A-Z]/g,/\d/g][o])||[]).sort().join``).join``


f([2, 0, 1], "a1B2c3")             == "123acB" &&
f([2, 1, 0], "aAaA909UuHWw9gh2")   == "02999AAHUWaaghuw" &&
f([2, 1, 0], "6Bx43")              == "346Bx" &&
f([1, 0, 2], "jfjf33g")            == "ffgjj33" &&
f([0, 2, 1], "AbC13")              == "b13AC" &&
f([1, 2, 0], "Qfl0l")              == "Q0fll" &&
f([0, 1, 2], "9870abcABC")         == "abcABC0789" &&
f([0, 2, 1], "test123")            == "estt123" &&
f([2, 0, 1], "WHAT")               == "AHTW" &&
f([2, 0, 1], "WhAt")               == "htAW" &&
f([1, 0, 2], "102BACbac")          == "ABCabc012"

Comments

स्टेल @ नील का बहुत साफ रीगेक्स सरणी विचार

— चार्ली व्यान

?प्रत्येक रेगेक्स में एस जोड़कर , यह सुनिश्चित करता है कि मैच परिणाम (ज्यादातर खाली तार, लेकिन वे वैसे भी गायब हो जाते हैं), से बचने (||[]), इस प्रकार आपको कुल मिलाकर 3 बाइट्स की बचत होती है।

— नील

@ नील अद्भुत, धन्यवाद .. मुझे यकीन नहीं था कि आप उन लोगों में क्यों थे: पी

— चार्ली व्यान

Answer 7

TSQL, 199 191 बाइट्स

golfed:

DECLARE @i varchar(99)='abA7B34',@s char(3)='213'

,@ varchar(99)=''SELECT @+=n FROM(SELECT top 99n FROM(SELECT top 99substring(@i,row_number()over(order by 1/0),1)n FROM sys.messages)c ORDER BY CHARINDEX(CHAR(ascii(n)/32+48),@s),n)d SELECT @

Ungolfed:

DECLARE @i varchar(99)='abA7B34'
-- 1 numbers, 2 upper case, 3 lower case
DECLARE @s char(3)='213'


,@ varchar(99)=''
SELECT @+=n
FROM
  (
    SELECT top 99 n 
    FROM
      (
         SELECT top 99substring(@i, row_number()over(order by 1/0), 1)n
         FROM sys.messages
      )c
    ORDER BY CHARINDEX(CHAR(ascii(n)/32+48),@s),n
  )d

SELECT @

बेला

Answer 8

APLX , 19 बाइट्स

s[(∊(⎕a⎕A⎕D)[a])⍋s]

⎕a⎕A⎕D निचले ऊपरी अंक

(... )[a]सरणी ए के अनुसार पुन: व्यवस्थित करें

∊ समतल करना

(... )⍋sउस "वर्णमाला" के अनुसार, ऐसे संकेत दें जो स्ट्रिंग s को सॉर्ट करें

s[... ]उपयोग कि क्रम बदलने के लिए रों

Comments

बहुत ख़राब Dyalog APL में Da नहीं है और अनुवाद को ऊपर नीचे करने के लिए अपरकेस समाधान में बहुत सारे बाइट्स लेता है :-) ऐसा नहीं है कि मैं Dyalog APL के लिए सुझाव नहीं दे रहा हूं जिसमें includea को शामिल किया गया है, क्योंकि इसकी उपयोगिता बहुत कम हो जाएगी जहां तक ​​मैं बता सकता हूं, कोड-गोल्फ चुनौतियों के लिए।

— lstefano

@lstefano मुझे पसंद नहीं है ⎕a, क्योंकि यह एक केस-संवेदी क्वाड नाम है। बहुत बेहतर (गोल्फ के लिए और सामान्य तौर पर) मैं किस चीज की पैरवी कर रहा हूं; प्राप्त करने के लिए ⌈और ⌊चरित्र डेटा पर मामला गुना करने के लिए, जैसे लालकृष्ण में फिर हम होगा ⌊⎕Aबजाय ⎕a।

— एडम जूल

Answer 9

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

lambda a,s:"".join(sum([[sorted(filter(eval(u),s))for u in["str.islower","str.isupper","str.isdigit"]][i]for i in a],[]))

Answer 10

क्लोजर, 74 बाइट्स

#(apply str(mapcat sort(for[i %](re-seq([#"[a-z]"#"[A-Z]"#"[0-9]"]i)%2))))

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

आप इसे यहां ऑनलाइन देख सकते हैं: https://ideone.com/dqAkxg

Answer 11

रेटिना , 43 39 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है। अनुगामी लाइनफीड महत्वपूर्ण है।

2=`.
!$&"
T04`¶d`#^@%
O`\W?.
O`.\w+
\W

इनपुट को पहली पंक्ति पर सीमांकक के बिना शून्य-आधारित सूची के रूप में क्रमबद्ध होने की उम्मीद है, और दूसरी पंक्ति पर छंटनी की जाने वाली स्ट्रिंग, जैसे

120
fOo42BaR

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

व्याख्या

मैं आपको कोड के माध्यम से चलने के लिए उपरोक्त इनपुट उदाहरण का उपयोग करूंगा:

120
fOo42BaR

चरण 1: प्रतिस्थापन

2=`.
!$&"

रेगेक्स ही बस है .(किसी भी गैर-लाइनफीड चरित्र से मेल खाता है), जो चारों ओर से घिरा हुआ है !..."। हालांकि, रेटिना को केवल रेगेक्स के दूसरे मैच के लिए प्रतिस्थापन लागू करने के लिए 2=एक सीमा है । तो हम इसे प्राप्त करते हैं:

1!2"0
fOo42BaR

चरण 2: लिप्यंतरण

T04`¶d`#^@%

लिप्यंतरण चरण बस एक चरित्र-दर-वर्ण प्रतिस्थापन करता है। ¶एक लाइनफीड का प्रतिनिधित्व करता है और dविस्तार करता है 0123456789(हालांकि हम बाद के सभी अंकों को अनदेखा कर सकते हैं 2)। इसका मतलब है कि, यह लिप्यंतरण निम्न मानचित्रण से मेल खाता है:

¶012
#^@%

04मोर्चे पर दो सीमाओं, जो एक साथ संकेत मिलता है कि केवल पहले चार इस सेट से पात्रों लिप्यंतरण किया जाना चाहिए। यह पहली पंक्ति के अंकों के साथ होता है, साथ ही साथ दो पंक्तियों को अलग करने वाला लाइनफीड होता है, इसलिए हमें यह मिलता है:

@!%"^#fOo42BaR

स्ट्रिंग के सामने अब हमें इन पात्रों के तीन जोड़े मिले हैं:

@!
%"
^#

ध्यान दें कि जोड़े के दूसरे वर्ण बस अपने सामान्य ASCII क्रम में हैं (और हमेशा समान रहेंगे)। हम मुख्य इनपुट में वर्णों के समूहों को आवश्यक क्रम में क्रमबद्ध करने के लिए बाद में इनका उपयोग करेंगे।

पहले अक्षर थोड़े अधिक दिलचस्प हैं: उनका महत्व यह है कि %एएससीआईआई तालिका में अंकों से @पहले आता है , ऊपरी मामले के अक्षरों (लेकिन अंकों के बाद) ^से पहले आता है , और निचले मामले के अक्षरों (लेकिन ऊपरी मामले के पत्रों के बाद) से पहले आता है। इससे हमें अक्षरों के सही सेट के साथ स्थिति मार्कर (प्रत्येक जोड़ी में दूसरा वर्ण) को समूह बनाने में मदद मिलेगी।

चरण 3: क्रमबद्ध करें

O`\W?.

यह एक सरल प्रकार का चरण है। यह दो वर्णों से मेल खाता है यदि पहला एक शब्द वर्ण नहीं है (इस प्रकार सभी तीन जोड़े जो मैंने अभी बात की है) या एक ही चरित्र से मेल खाते हैं अन्यथा (मुख्य इनपुट के प्रत्येक वर्ण को व्यक्तिगत रूप से मेल खाते हैं), और उन तार को सॉर्ट करें। इसके दो उद्देश्य हैं: यह प्रत्येक समूह के भीतर वर्णों को सही क्रम में लाता है (और चूंकि छंटाई स्थिर है, यह क्रम अगले चरण में गड़बड़ नहीं होगा), और %@^मार्करों के कारण यह जोड़े को सम्मिलित करता है। सही स्थिति:

%"24@!BOR^#afo

चरण 4: क्रमबद्ध करें

O`.\w+

यह चरण .\w+रेगेक्स के सभी मैचों को क्रमबद्ध करता है, जो लालच के कारण, एक स्थिति मार्कर (यानी एक !"#) से मेल खाता है, इसके बाद सभी शब्द वर्णों के साथ। यही है, यह इन तीन तारों को क्रमबद्ध करता है, जिसका क्रम केवल मार्कर वर्ण द्वारा निर्धारित किया जाता है:

"24! BOR #afo

हालांकि यह उन मार्करों के आसपास फेरबदल करता है (जबकि अन्य तीन मार्करों को जगह में छोड़ते हुए), सबसे महत्वपूर्ण बात यह अंक और अक्षरों को सही क्रम में लाता है:

%!BOR@"24^#afo

चरण 5: प्रतिस्थापन

\W

जो कुछ बचा है वह थोड़ा साफ-सुथरा है, जहां हम सभी मार्करों को हटाकर उन्हें मिलान करते हैं और उन्हें कुछ भी नहीं देते हैं।

Answer 12

जावास्क्रिप्ट (ईएस 6), 65

नोट: 'प्राकृतिक' ASCII ऑर्डर 0-9, AZ, az है, जो कि ओपी 0,1,2 के ठीक विपरीत है। इसलिए

• अलग-अलग रन में स्ट्रिंग को अमान्य वर्ण जोड़ने का आदेश दें
• इसे 3 सीमेन में विभाजित करें - अमान्य वर्ण प्रत्येक को चिह्नित करते हैं
• अनुरोधित क्रम में एक-एक करके सेगमेंट प्राप्त करें
• पुनः

s=>w=>w.map(w=>[...'^@'+s].sort().join``.split(/\W/)[2-w]).join``

F=s=>w=>w.map(w=>[...'^@'+s].sort().join``.split(/\W/)[2-w]).join``

;[['201','a1B2c3','123acB']
,['210','aAaA909UuHWw9gh2','02999AAHUWaaghuw']
,['210','6Bx43','346Bx']
,['102','jfjf33g','ffgjj33']
,['021','AbC13','b13AC']
,['120','Qfl0l','Q0fll']
,['012','9870abcABC','abcABC0789']
,['021','test123','estt123']
,['201','WHAT','AHTW']
,['201','WhAt','htAW']
,['102','102BACbac','ABCabc012']]
.forEach(t=>{
  var w=t[0],s=t[1],k=t[2], r=F(s)([...w])
  console.log(w,s,r,(r==k?'OK':'KO (expected '+k+')'))
})

Answer 13

हास्केल, 62 63 बाइट्स

a#b=[c|i<-b,c<-[' '..],d<-a,d==c,div(fromEnum c)16==[6,4,3]!!i]

प्रयोग उदाहरण: "cD12ab" # [2,0,1]-> "12abcD"।

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

i<-b                                  -- loop i through the input array
   [c|   c<-[' '..]]                  -- loop through all chars c
       d<-a                           -- loop through all chars d in the input string
       d==c                           -- and keep those that are in the input string
       div(fromEnum c)16==[6,4,3]!!i  -- and where the the ascii value divided by
                                      -- 16 equals the number from [6,4,3] indexed
                                      -- by the current i

संपादित करें: @ क्रिसियन सिवर्स को एक बग मिला। धन्यवाद! 1 अतिरिक्त बाइट के लिए निश्चित।

Comments

एक से अधिक बार होने वाले चार्ट के बारे में क्या?

— क्रिश्चियन सिवर्स

@ChristianSievers: आप सही कह रहे हैं, यह एक बग है। फिक्स्ड। धन्यवाद!

— नाइमी जूल

Answer 14

स्टैक्स , 15 बाइट्स

┐°!'àÉgYg8∟╗`╖ë

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

यह 15 बाइट सबमिशन CP437 कैरेक्टर सेट के एक वेरिएंट में पैक किया गया है। इसी ascii प्रतिनिधित्व 18 बाइट्स लेता है:

EVlVd+26/s@:fs{[Io

बहुत यकीन है कि यह हालांकि नीचे छंटनी की जा सकती है।

E                   Put the two inputs on main stack
 Vl                 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
   Vd               "0123456789"
     +              Concatenate
      26/           Partition to blocks of size 26 (array `a`)
         s@         Index array `a` with the input index array
           :fs      Flatten to get a string `s`
              {[Io  Order the input string
                        Using the char array `s` as the key
                    Implicit output

VlVd+यह भी हो सकता है VLA|(, जो बाएं हाथ 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZसे दस हाथियों को घुमाता है। पूरे कोड भी हो सकता है VlVd+26/,e@:f,{[Io, जो इनपुट ढेर दो बार के बजाय पढ़ता है उन सब को मुख्य ढेर करने के लिए शुरुआत में पढ़ने के लिए, और एक अलग (अधिक परंपरागत) इनपुट प्रारूप का उपयोग करता है, के रूप में में दिखाया गया है इस ।

Answer 15

दिल्लोग एपीएल , 22 बाइट्स

s[s⍋⍨∊(819⌶⎕A)⎕A⎕D[a]]

(819⌶⎕A) अपरकेस वर्णमाला को निचले हिस्से में मोड़ो

(… )⎕A⎕D[a]कम ऊपरी अंक सरणी ए के अनुसार पुन: व्यवस्थित

∊ समतल करना

s⍋⍨स्ट्रिंग के लिए रों , सूचियों के प्रकार हैं मिल रहा है कि "वर्णमाला" के अनुसार

s[... ]उपयोग कि क्रम बदलने के लिए रों

Comments

mmm .... 819m केवल Dyalog APL के यूनिकोड संस्करण में मौजूद है। इसलिए मैं यह अनुमान लगाऊंगा कि बाइट की गिनती को 2 से गुणा किया जाना चाहिए क्योंकि इनपुट प्रभावी रूप से यूनिकोड प्रविष्टि बिंदुओं से बना है। क्या एपीएल सबमिशन के लिए बाइट काउंटिंग की मेरी समझ गलत है?

— lstefano

@lstefano यूनिकोड संस्करण क्लासिक कार्यस्थानों को लोड करने में सक्षम है, है ना?

— एडम जूल

यह डरपोक है ;-)

— lstefano

Answer 16

PowerShell v2 +, 107 बाइट्स

param($n,[char[]]$s)-join(-join(($s=$s|sort)|?{$_-ge97}),-join($s|?{$_-in65..96}),-join($s|?{$_-lt58}))[$n]

मैं regex का उपयोग करके एल्गोरिदम की खोज कर रहा हूं, लेकिन इस प्रकार वे सभी लंबे समय तक लगते हैं।

स्पष्ट सरणी के रूप में इनपुट लेता है $n(नीचे उदाहरण देखें) और स्ट्रिंग $sजो तुरंत एक चार-सरणी में डाली जाती है। हम फिर एक नए गतिशील सरणी के तीन तत्वों का निर्माण कर रहे हैं, उनमें से प्रत्येक एक के साथ समझाया -join:
- (($s=$s|sort)|?{$_-ge97})
- ($s|?{$_-in65..96})
-($s|?{$_-lt58})

पहले हम $sइसे माध्यम से लेते हैं और चलाते हैं Sort-Object। शुक्र है, क्योंकि हम पहले ही इसे चार-सरणी के रूप में डाल चुके हैं, यह केस-सेंसिटिव सॉर्टिंग है। यह फिर से सहेजा जाता है $sऔर फिर Where-Objectइससे अधिक 97(यानी, ASCII लोअरकेस a-z) के एक खंड के साथ पाइप किया जाता है । दूसरा है A-Zऔर तीसरा है 0-9।

इस प्रकार अब हमारे पास एक स्ट्रिंग है, जहां प्रत्येक स्ट्रिंग को तीन वर्ण प्रकारों में से एक बनाया जाता है और क्रमबद्ध किया जाता है। हम उस के साथ [$n]और फिर -joinपरिणाम के साथ मिलकर हमारे अंतिम आउटपुट स्ट्रिंग बनाते हैं। कि पाइपलाइन पर छोड़ दिया गया है और मुद्रण निहित है।

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

PS C:\Tools\Scripts\golfing> $test = (@(2,0,1),'a1B2c3'), (@(2,1,0),'aAaA909UuHWw9gh2'), (@(2,1,0),'6Bx43'), (@(1,0,2),'jfjf33g'), (@(0,2,1),'AbC13'), (@(1,2,0),'Qfl0l'), (@(0,1,2),'9870abcABC'), (@(0,2,1),'test123'), (@(2,0,1),'WHAT'), (@(2,0,1),'WhAt'), (@(1,0,2),'102BACbac')

PS C:\Tools\Scripts\golfing> $test |%{"($($_[0]-join',')) & $($_[1])".PadRight(28)+" -> " + (.\post-determined-array-sorting.ps1 $_[0] $_[1])}
(2,0,1) & a1B2c3             -> 123acB
(2,1,0) & aAaA909UuHWw9gh2   -> 02999AAHUWaaghuw
(2,1,0) & 6Bx43              -> 346Bx
(1,0,2) & jfjf33g            -> ffgjj33
(0,2,1) & AbC13              -> b13AC
(1,2,0) & Qfl0l              -> Q0fll
(0,1,2) & 9870abcABC         -> abcABC0789
(0,2,1) & test123            -> estt123
(2,0,1) & WHAT               -> AHTW
(2,0,1) & WhAt               -> htAW
(1,0,2) & 102BACbac          -> ABCabc012

Answer 17

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

@ डेनिस जवाब से पोर्ट किया गया।

->a,s{s.chars.sort_by{|c|a.index(3-c.ord/32).to_s+c}*''}

एक वैकल्पिक 58 बाइट्स समाधान जो मुझे बेहतर लगता है, @ निएल से प्रेरित है और उसके जवाब से थोड़ा संशोधित हुआ है।

->a,s{a.map{|i|s.scan([/[a-z]/,/[A-Z]/,/\d/][i]).sort}*''}

या तो ऑनलाइन संस्करण की कोशिश करो! (टिप्पणी-आउट संस्करण वैकल्पिक समाधान है)

Answer 18

32-बिट x86 मशीन कोड, 70 बाइट्स

हेक्स में:

fc31c031c95189e3ac84c0740a34cf0404880c0341ebf189fe9160ac88c2c0e805d788c652ac88c2c0e805d788c658740e6639d076029241aa92aa4e4febdc85c96175d658c3

यह प्रक्रिया 3-चार (0..2) नेल-टर्मिनेटेड स्ट्रिंग इन ESIऔर सॉर्ट करने के लिए स्ट्रिंग में वर्ण वर्ग सॉर्टिंग ऑर्डर की उम्मीद करती है EDI। छँटाई बुलबुला प्रकार के अत्यंत उप-इष्टतम (प्रदर्शन-वार) संस्करण का उपयोग करके इन-प्लेस में की जाती है।

0:  fc                  cld
1:  31 c0               xor eax, eax
3:  31 c9               xor ecx, ecx
5:  51                  push ecx        ;Allocate 4 bytes on the stack
6:  89 e3               mov ebx, esp    ;char EBX[4]
_loop0:                                 ;Parsing class order string
8:  ac                  lodsb
9:  84 c0               test al,al      ;Break on NULL
b:  74 0a               jz _break0
d:  34 cf               xor al, 0xCF    ;AL=~atoi(AL)
f:  04 04               add al, 4       ;'0'->3, '1'->2, '2'->1
11: 88 0c 03            mov [ebx+eax], cl    ;EBX[AL]=CL
14: 41                  inc ecx
15: eb f1               jmp _loop0
_break0:
17: 89 fe               mov esi,edi
19: 91                  xchg eax,ecx    ;ECX=0
_bsort:
1a: 60                  pusha
_cx2b:
1b: ac                  lodsb           ;Get the first char to compare
1c: 88 c2               mov dl,al       ;Save to DL
1e: c0 e8 05            shr al,5        ;Char class: [0-9]->1, [A-Z]->2, [a-z]->3
21: d7                  xlat            ;AL=EBX[AL] - priority for the char class 
22: 88 c6               mov dh,al       ;... goes to DH
24: 52                  push edx        ;First "comparable char" in DX goes to the stack
25: ac                  lodsb           ;Get the second char to compare
26: 88 c2               mov dl,al       ;\
28: c0 e8 05            shr al,5        ; > Same as the above
2b: d7                  xlat            ;/
2c: 88 c6               mov dh, al      ;Second "comparable char" in DX
2e: 58                  pop eax         ;The first one goes to AX
2f: 74 0e               jz _endpass     ;ZF is set by the last 'shr', and only on AL==0
31: 66 39 d0            cmp ax,dx       ;Upper halves of 32-bit regs may contain trash
34: 76 02               jbe _sorted
36: 92                  xchg eax,edx    ;Now AX<=DX
37: 41                  inc ecx         ;Swap counter
_sorted:
38: aa                  stosb           ;Store AL in-place
39: 92                  xchg eax,edx    ;AL=DL
3a: aa                  stosb           ;Store the second char
3b: 4e                  dec esi         ;Move pointers...
3c: 4f                  dec edi         ;...back one byte
3d: eb dc               jmp _cx2b       ;Repeat with the next two chars
_endpass:
3f: 85 c9               test ecx,ecx    ;Full pass completed, checking # of swaps made
41: 61                  popa            ;Restores ECX(0), ESI, EDI. Doesn't affect flags
42: 75 d6               jnz _bsort      ;If there were changes, repeat
_end:
44: 58                  pop eax         ;Deallocate EBX[]
45: c3                  ret

Answer 19

एमएसीएस लिस्प, 183 बाइट्स

(lambda(s p)(let(l u n)(apply'concat(mapcar(lambda(l)(sort l'<))(dolist(e(string-to-list s)(mapcar(lambda(i)(nth i(list l u n)))p))(push e(cond((< ?` e)l)((< ?@ e)u)((< ?/ e)n))))))))

जावा से थोड़ा कम ...

Answer 20

क्लोजर, 77 बाइट्स

#(apply str(mapcat sort(map(group-by(fn[v](condp <(int v)90 0,57 1,2))%2)%)))

re-seqआधारित के रूप में बहुत कम नहीं है , और मैं यह पता नहीं लगा सका कि (apply str(mapcat sort(map(...))))कम जगह में " " कैसे व्यक्त किया जाए । group-byएक हैश-मैप बनाता है जिसे एक फ़ंक्शन के रूप में उपयोग किया जा सकता है, जब 0 और 2 के बीच एक इंगर के साथ क्वियर किया जाता है यह संबंधित समूह को वापस करता है, यह वर्णों के तीन अलग-अलग वर्गों का आदेश देता है।

यह re-seqसमाधान की तुलना में अधिक कॉम्पैक्ट होगा यदि इसमें अधिक वर्ण वर्ग को संभालना है क्योंकि यह केवल 57 1,अभिव्यक्ति के लिए 8 के बजाय 5 अतिरिक्त वर्ण / समूह लेता है #"[a-z]"।

Answer 21

पायथन 2, 140 117 101 100 99 बाइट्स

हर कोई कहता है, "ईडब्ल्यूए!"। कम से कम यह पठनीय है ... खांसी वास्तव में खांसी नहीं है

lambda l,s:`sorted(s,key=lambda c:[[c<'a',c<'A'or'Z'<c,c>'9'][l[i]]for i in 0,1,2]+[ord(c)])`[2::5]

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

Answer 22

आर , 101 बाइट्स

function(a,s,o=unlist(list(letters,LETTERS,0:9)[a]))cat(o[sort(match(strsplit(s,'')[[1]],o))],sep='')

इस क्रम से मिलान करने के लिए इनपुट स्ट्रिंग के az, AZ और 0-9 के साथ एक वेक्टर बनाता है।

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

Answer 23

जे, 40 बाइट्स

;@:{[:(<@/:~@}./.~2-64 96 I.3&u:)'aA0'&,

Answer 24

जावा 8, 221 212 193 156 बाइट्स

मुझे निश्चित रूप से अपनी चुनौती का जवाब देने की कोशिश करनी चाहिए। :) (और जावा में हमेशा की तरह।)

a->i->{for(byte c[],j=0;j<3;System.out.print(new String(c)))java.util.Arrays.sort(c=i.replaceAll("[^a-z];[^A-Z];[^0-9]".split(";")[a[j++]],"").getBytes());}

-28 बाइट्स ने @cliffroot को धन्यवाद दिया ।

स्पष्टीकरण:

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

a->i->{          // Method with integer-array and String parameters and no return-type
  for(byte c[],  //  Temp byte-array
      j=0;j<3;   //  Loop from 0 to 3 (exclusive)
      System.out.print(new String(c)))
                 //    After every iteration: print the byte-array as String
    java.util.Arrays.sort(
                 //   Sort the byte-array
      c=         //    After we've replaced the byte-array with
        i.replaceAll("[^a-z];[^A-Z];[^0-9]".split(";")[a[j++]],"").getBytes());}
                 //    all bytes of the uppercase letters, lowercase letters, or digits,
                 //    depending on the next number in the input-array

Comments

आप के साथ अपने regexps को बदल सकते हैं [^a-z] [^A-Z] [^0-9]और आप getBytes()इसके बजाय का उपयोग कर सकते हैंtoCharArray()

— क्लिफरोट

@cliffroot धन्यवाद। मैं रेगेक्स पर बहुत बुरा हूं, लेकिन ^(नहीं) का उपयोग करना बहुत बुरा नहीं था ..;)

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

दोहराए जाने वाले replaceAllकॉलों को हटाता हैString c(int[]a,String z){String r[]={"[^a-z]","[^A-Z]","[^0-9]"},o="";for(byte c[],i=0;i<3;){c=z.replaceAll(r[a[i++]],"").getBytes();java.util.Arrays.sort(c);o+=new String(c);}return o;}

— क्लिफरॉट