दिए गए आदेश द्वारा एक स्ट्रिंग को क्रमबद्ध करें

23

आपकी चुनौती एक स्ट्रिंग को क्रमबद्ध करने की है, लेकिन सामान्य वर्णमाला क्रम (abc..xyz) के बजाय, आप एक निर्दिष्ट वर्णमाला द्वारा तार छांट रहे होंगे।

आपको एक प्रोग्राम या फ़ंक्शन लिखना होगा जो दो इनपुट लेता है: एक वर्णमाला ए और एक स्ट्रिंग एस । दोनों में केवल निचले अक्षरों में अंग्रेजी के अक्षर होंगे और दोनों में कम से कम एक अक्षर होगा।

आपको S में अक्षरों को स्थानांतरित करना होगा ताकि A में पहले दिखाई देने वाला अक्षर पहले दिखाई दे, फिर जो भी अक्षर A में दूसरा दिखाई दे , आदि। S में कुछ अक्षर हो सकते हैं जो A में दिखाई नहीं देते हैं , इन्हें अंत में छोड़ दिया जाना चाहिए और एक दूसरे के सापेक्ष नहीं चले गए।

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

A       S               Result
axd     haxuizzxaxduxha aaaxxxxdhuizzuh
a       xyz             xyz
abc     dcba            abcd
il      nmiuplliu       iillnmupu
asdf    qwerty          qwerty

सबसे शानदार बाइट्स जीतता है!

code-golf  string 
— पावेल
स्रोत
क्या हम सिंगलटन स्ट्रिंग्स के एक सरणी को प्रिंट / वापस कर सकते हैं? क्या हम इनपुट के रूप में एक स्ट्रिंग और एक सरणी सिंगलटन स्ट्रिंग ले सकते हैं?
— डेनिस
@ डेनिस हां, दोनों तार के अच्छे निरूपण हैं।
— पावेल
क्या हम व्यक्तिगत पात्रों की एक सरणी के रूप में या दोनों इनपुट ले सकते हैं?
— झबरा
@ शैगी एक स्ट्रिंग एक चरित्र सरणी है, इसलिए हां।
— पावेल

जवाबों:

5

05AB1E , 4 बाइट्स

Rvy†

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

व्याख्या

R     # Reverse the alphabet
 vy   # For each letter ...
   †  # Push S with the current letter filtered to the front
— Kaldo
स्रोत
से होशियार Σ²sk>।
— मैजिक ऑक्टोपस Urn
R€†हालांकि उम्मीद के मुताबिक काम करना बहुत बुरा है :)। कभी-कभी यह एक छोटे vyलूप के रूप में काम कर सकता है । अच्छा जवाब है यार।
— मैजिक ऑक्टोपस Urn
10

पायथन 3 , 50 47 46 44 बाइट्स

-3 बाइट्स ngn के लिए धन्यवाद!

-1 बाइट थैंक्स टू मायपेटियन

lambda a,s:s.sort(key=lambda c:a.find(c)%27)

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

एक स्ट्रिंग में वर्णमाला और स्ट्रिंग के रूप में वर्णों की एक सूची के रूप में लेता है और जगह में सूची को सॉर्ट करता है।

यह %27सुनिश्चित करता है कि यदि वर्ण वर्णमाला में नहीं है, तो सूचकांक वापस आ गया, बाकी वर्णमाला के बाद।

— मजाक कर रहा है
स्रोत
2
-a[::-1].find(c)->(a+c).find(c)
— ngn
1
(a+c).find(c)-> a.find(c)%271 बाइट बचाने के लिए
— mypetlion
7

पर्ल 6 ,  55  43 बाइट्स

->\A,\S{[~] S.comb.sort:{%(A.comb.antipairs){$_}//∞}}

कोशिश करो

->\A,\S{[~] S.comb.sort:{A.index($_)//∞}}

कोशिश करो

विस्तारित:

-> \A, \S {
  [~]  # reduce using &infix:«~» (shorter than `.join`)

    S.comb.sort: # split into character list and sort by:

      {  # bare block lambda with implicit parameter $_

        A.index( $_ ) # get the position

        //  # if it is undefined (not in `A`)
        ∞   # return Inf instead (so it comes at end of result)
      }
}
— ब्रैड गिल्बर्ट b2gills
स्रोत
चूंकि इनपुट में केवल 26 विभिन्न वर्ण होंगे, और up 3 बाइट्स हैं, आप इसे 27 से बदल सकते हैं और यह अभी भी काम करेगा और एक बाइट को बचाएगा।
— पावेल
6

हास्केल , 40 34 बाइट्स

-6 बाइट्स लाईकोनी के लिए धन्यवाद ।

foldr(\c->r(==c)<>r(/=c))
r=filter

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

पहली पंक्ति एक अभिव्यक्ति है जो दो तर्क लेती है: एस और ए ।

— user28667
स्रोत
1
अच्छा! आप छोड़ भी सकते हैं f=क्योंकि अनाम फ़ंक्शंस की अनुमति है।
— लकोनी
1
इसके अलावा (<>)अब प्रस्तावना में है, इसलिए इसे foldr(\c->r(==c)<>r(/=c))34 बाइट्स के लिए छोटा किया जा सकता है : इसे ऑनलाइन आज़माएं!
— लकोनी
6

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

{xrINo

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

यह ऐसा करने वाले ब्लॉक द्वारा सॉर्ट करता है।

  • वर्णमाला का उलटा।
  • उल्टे अक्षर में प्रत्येक वर्ण का सूचकांक प्राप्त करें। अनुपलब्ध पैदावार -1।
  • सूचकांक को नापें।
— पुनरावर्ती
स्रोत
5

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

def f(a,s):s.sort(None,a[::-1].find,1)

एक एक स्ट्रिंग होनी चाहिए, एस लंबाई 1. की स्ट्रिंग की एक सूची च प्रकार रों जगह में।

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

वैकल्पिक संस्करण, स्ट्रिंग I / O, 48 बाइट्स

lambda a,s:`sorted(s,None,a[::-1].find,1)`[2::5]

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

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

s.sort(None,a[::-1],1)के लिए आशुलिपि है s.sort(cmp=None,key=a[::-1],reverse=1)।

से डॉक्स :

रिवर्स एक बूलियन मूल्य है। यदि सेट किया जाता है True, तो सूची तत्वों को क्रमबद्ध किया जाता है जैसे कि प्रत्येक तुलना को उलट दिया गया था।

— डेनिस
स्रोत
TIL सॉर्ट 4 तर्क ले सकता है।
— पावेल
केवल पायथन 2. अजगर 3 पदावनत में cmpऔर बना दिया keyऔर reverseकेवल कीवर्ड वाला तर्क है, इसलिए इसके list.sortकेवल लेता है एक स्थितीय तर्क।
— डेनिस
4

जे , 5 बाइट्स

]/:i.

डायएडिक क्रिया, इसके बाईं ओर वर्णमाला और दाईं ओर छाँटने के लिए स्ट्रिंग।

i. अगर नहीं मिला तो वर्णमाला में स्ट्रिंग के पात्रों की इंडोल ढूंढता है।

   'axd' i. 'haxuizzxaxduxha'
3 0 1 3 3 3 3 1 0 1 2 3 1 3 0

/: दाएं वाले में निर्दिष्ट आदेश के अनुसार इसके बाएं एग्रेट को सॉर्ट करें।

] कठोरता तर्क (स्ट्रिंग)

  'haxuizzxaxduxha' /: 3 0 1 3 3 3 3 1 0 1 2 3 1 3 0
aaaxxxxdhuizzuh

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

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

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

lambda a,s:sorted(s,key=lambda c:-a[::-1].find(c))

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

लेता है aऔर sतार के रूप में; सिंगलटन स्ट्रिंग्स की सूची देता है।

नोट: आउच! तय करने के लिए 15 बाइट्स मिले ...

— चास ब्राउन
स्रोत
हा! यह वास्तव में मेरे उत्तर के लिए मेरे मूल कोड के समान है । महान दिमाग एक जैसा सोचते हैं
— जो किंग
1
@ राजा: मेरे विचारों को नियंत्रित करना बंद करो! :)
— चास ब्राउन
4

के (ngn / k) , 9 बाइट्स

{y@>-x?y}

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

{... }तर्कों के साथ एक समारोह है xऔरy

x?yyमें अपनी पहली घटना के सूचकांक में प्रत्येक तत्व के लिए पाता है x; यदि कोई तत्व नहीं पाया जाता है x, तो इसका सूचकांक माना जाता है 0N(-2 63 )

-सभी सूचकांकों को छोड़ देता है, सिवाय इसके कि 0N-s बरकरार रहता है, क्योंकि 2 63 63-2 63 (mod 2 64 )

> क्रमबद्ध-अवरोही क्रमपरिवर्तन लौटाता है

y@yउस के साथ अनुक्रमित

— NGN
स्रोत
3

चारकोल , 13 बाइट्स

Ｆθ×ι№ηιΦη¬№θι

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

 θ              First input
Ｆ               Loop over characters
     η          Second input
      ι         Current character
    №           Count matches
   ι            Current character
  ×             Repeat
                Implicitly print
        η       Second input
       Φ        Filter
           θ    First input
            ι   Current character
          №     Count matches
         ¬      Logical not
                Implicitly print non-matching characters
— नील
स्रोत
3

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

fⱮ;ḟ

एक डायडिक लिंक बाईं ओर स्ट्रिंग को स्वीकार करता है और दाईं ओर वर्णमाला (वर्णों की सूची के रूप में) और परिणाम लौटाता है (वर्णों की सूची के रूप में भी)।

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

कैसे?

fⱮ;ḟ - Link: string; alphabet                                    e.g. smallnotxl; xl
 Ɱ   - map (for each character in the alphabet):                      1=x; 2=l
f    -   filter keep (keep occurrences of this character from string)   x    lll -> xlll
   ḟ - filter discard (discard all alphabet characters from string)   smanot
  ;  - concatenate                                                    xlllsmanot
— जोनाथन एलन
स्रोत
3

एपीएल (Dyalog यूनिकोड) , 5 बाइट्स SBCS

अनाम मौन उपसर्ग फ़ंक्शन, [string,ordering]तर्क के रूप में ले रहा है।

⍋⍨/⌷⊃

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

… / निम्न कार्य द्वारा कम करें:

  … ⍨ अर्थात् निम्नलिखित फ़ंक्शन का उलटा-तर्क संस्करण:

  ⍋ बाएँ क्रम के अनुसार दाएँ स्ट्रिंग को ग्रेड करें (लापता अक्षर अंत में जाते हैं)

⌷ सूचकांक में…

⊃ तर्क का पहला तत्व (यानी स्ट्रिंग)

— एडम
स्रोत
3

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

वाक्य रचना currying में इनपुट लेता है (a)(s), जहां एक एक स्ट्रिंग है और एस वर्णों की एक सरणी है। वर्णों की एक सरणी देता है।

a=>s=>s.sort((b,c)=>(g=c=>-1/a.search(c))(b)-g(c))

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

कैसे?

हम सहायक फंक्शन जी को परिभाषित करते हैं () :

c => -1 / a.search(c)

कौन सा रिटर्न:

  • 1 यदि c वर्णमाला से संबंधित नहीं है
  • अन्यथा (-f, -1, -1/2, -1/3, आदि) में c की स्थिति के आधार पर [-Inf, 0) में एक फ्लोट मान ।

हम प्रकार [] एस कंप्यूटिंग द्वारा ग्राम (ग) - जी (ख) वर्णों की प्रत्येक जोड़ी के लिए (ख, ग) के कॉलबैक करने के लिए पारित कर दिया () तरह ।

क्योंकि स्पाइडरमोंकी में सॉर्ट () का कार्यान्वयन स्थिर है, एस के सभी वर्ण [] जो वर्णमाला से संबंधित नहीं हैं, वे केवल उपस्थिति के क्रम में अंत में स्थानांतरित हो जाते हैं और एक दूसरे के साथ तुलना किए जाने पर अपरिवर्तित होते हैं।

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

करी वाक्यविन्यास में इनपुट लेता है (a)(s), जहाँ दोनों ए और एस वर्णों के सरणियाँ हैं। एक स्ट्रिंग लौटाता है।

a=>s=>a.map(C=>s=s.filter(c=>c!=C||!(o+=c)),o='')&&o+s.join``

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

— Arnauld
स्रोत
3

आर , 69 62 58 बाइट्स

function(a,s)c(rep(a,rowSums(outer(a,s,"=="))),s[!s%in%a])

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

इनपुट और आउटपुट व्यक्तिगत पात्रों के वैक्टर हैं।

स्पष्टीकरण:

function(a,s)c(                              ,           ) #combine:
                   a,                                      #[each char in a
               rep(                                        #each repeated
                     rowSums(               )              #the number of
                             outer(a,s,"==")               #occurrence in s]
                                              s            #with s
                                               [ s%in%a]   #all chars in a
                                                !          #omitted
— Jayce
स्रोत
3

ब्रेन-फ्लैक (ब्रेनहैक) , 118 बाइट्स

{({}(<>))<>}{}<>{<>([[]()]<{<>(({})<({}<>[({}<>)]){(<()>)}{}{}>)<>}<>({}<{({}<>)<>}<>>)>[]){({}()<(({}))>)}{}{}<>{}}<>

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

इनपुट पहली स्ट्रिंग है, उसके बाद एक नल है, उसके बाद दूसरा स्ट्रिंग है। एक संस्करण जो विभाजक के रूप में एक नई लाइन का उपयोग करता है, 24 बाइट जोड़ता है:

ब्रेन-फ्लैक , 142 बाइट्स

(()){{}(({}(<>))[(()()()()()){}]<>)}{}<>{<>([[]()]<{<>(({})<({}<>[({}<>)]){(<()>)}{}{}>)<>}<>({}<{({}<>)<>}<>>)>[]){({}()<(({}))>)}{}{}<>{}}<>

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

व्याख्या

# Move A to other stack reversed
# Zeroes are pushed under each character for later.
# (This is the only part that needs to change in order to use newline as separator.)
{({}(<>))<>}{}<>

# For each character in A, starting at the end:
{

  # Track current length of S.
  <>([[]()]<

    # For each character in S:
    {

      # While keeping character from A
      <>(({})<

        # Move character from S to second stack and push difference
        ({}<>[({}<>)])

        # Delete character if equal
        {(<()>)}{}{}

      >)

    <>}

    # Move S back to first stack while maintaining character from A
    <>({}<{({}<>)<>}<>>)

  # Push difference between old and new lengths of S
  >[])

  # Insert character from A at beginning of S that many times
  {({}()<(({}))>)}{}{}

<>{}}<>
— Nitrodon
स्रोत
2

सी (जीसीसी) , 97 बाइट्स

f(D,d,S,s,i,o)char*D,*S;{
  while(d--){
    for(i=o=s;i--;)S[i]-D[d]?S[--o]=S[i]:0;
    while(o--)S[o]=D[d];
  }
}

सभी व्हाट्सएप (स्पेस और न्यूलाइन्स)उपरोक्त कोड में केवल पठनीयता के लिए हैं और इन्हें हटा दिया जाना चाहिए।

डिक्शनरी में पास Dऔर लंबाई है d, स्ट्रिंग में पास Sऔर लंबाई है s। iऔर oछोड़ दिया जाना चाहिए।

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

— user202729
स्रोत
2

जावा 8, 98 बाइट्स

a->s->{for(int i=a.length;i-->0;s=s.replaceAll("[^"+a[i]+"]","")+s.replaceAll(a[i],""));return s;}

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

स्पष्टीकरण:

a->s->{       // Method with String-array and String parameters, and String return-type
  for(int i=a.length;i-->0;
              //  Loop backwards over the alphabet
    s=        //   Replace the current `s` with:
      s.replaceAll("[^"+a[i]+"]","") 
              //    All the current characters of `a` in `s`
      +s.replaceAll(a[i],""));
              //    Concatted with everything else
  return s;}  //  Return the modified `s`
— केविन क्रूज़सेन
स्रोत
जावा 11 की नई String.repeat(int)विधि के साथ भी कम नहीं हो सकता है । अच्छा! :)
— ओलिवियर ग्रेजायर
@ OlivierGrégoire ओह, पता नहीं था कि जावा 11 की शुरुआती पहुँच पहले से ही उपलब्ध थी। .repeat(n)हालांकि यह आशाजनक लगता है। : डी
— केविन क्रूज़सेन
2

पर्ल 5 के साथ -pF, 43 बाइट्स

$_=<>;print$F[0]x s/@{[shift@F]}//g while@F

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

— डोम हेस्टिंग्स
स्रोत
क्या कोई ऐसा झंडा नहीं है जो आपको $_=<>;मुफ्त में दे?
— पावेल
@Pavel हाँ, माफ करना, मैं इसे आबाद करने के लिए उपयोग कर रहा हूँ @F, लेकिन मैंने इसे हेडर में नहीं जोड़ा! अभी करता हूँ! धन्यवाद!
— डोम हेस्टिंग्स
आप इसे 10 बाइट्स काट सकते हैं और अभी भी उसी तर्क का उपयोग कर सकते हैं: इसे ऑनलाइन आज़माएं!
— एक्सकली
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.