Buradaki zorluk bir dizgiyi sıralamaktır, ancak normal alfabetik sıraya göre değil (abc..xyz), dizeleri belirtilen bir alfabeye göre sıralayacaksınız.

Bir alfabe: Bir program veya fonksiyon iki giriş alır yazmalısınız A ve dize S . Her ikisi de sadece küçük harfli İngilizce harfler içerecek ve her ikisi de en az bir karakter içerecektir.

Sen harfleri taşımak zorundadır S ilk görünen harf olacak şekilde A ikinci görünür ardından hangisi mektup, ilk göründüğü A , vb bazı harfler olabilir S görünmez A , bu uçta bırakılmalıdır ve birbirlerine göre hareket etme.

Test durumları:

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

En az bayt kazanır!

05AB1E , 4 bayt

Rvy†

Çevrimiçi deneyin!

açıklama

R     # Reverse the alphabet
 vy   # For each letter ...
   †  # Push S with the current letter filtered to the front

Python 3 , 50 47 46 44 bayt

Ngn sayesinde -3 bayt!

Mypetlion sayesinde -1 bayt

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

Çevrimiçi deneyin!

Alfabenin olduğu bir dizgiyi ve dize olarak bir karakter listesini alır ve listeyi yerinde sıralar.

%27Olmasını sağlar karakter alfabesinde değilse o, endeks alfabenin dinlendikten sonra koyar döndü.

Haskell, 42 bayt

a#s=[c|c<-a,d<-s,c==d]++[c|c<-s,all(/=c)a]

Çevrimiçi deneyin!

a#s=                     -- take alphabet a and string s
        c<-a             -- for all c in a
             d<-s        --   for all d in s
    [c|       c==d]             keep c if c equals d
   ++                    -- append
    [c|c<-s        ]     --   all c of s
         ,all(/=c)a      --   that are not in a 

Perl 6 ,  55  43 bayt

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

Dene

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

Dene

Expanded:

-> \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)
      }
}

Haskell , 40 34 bayt

-6 bayt Laikoni sayesinde çok büyük .

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

Çevrimiçi deneyin!

Birinci satır, iki bağımsız değişken olduğunu ifade S ve A .

Stax , 6 bayt

{xrINo

Koş ve hata ayıkla

Bu, bunu yapan bir bloğa göre sıralar.

• Alfabeyi ters çevir.
• Tersine çevrilmiş alfabedeki her karakterin dizinini alın. Kayıp verim -1.
• Dizini olumsuzla.

Python 2,38 bayt

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

Bir bir dize olmalıdır, s uzunluğu 1'in dizeleri listesini f sıralar s yerinde.

Çevrimiçi deneyin!

Alternatif sürüm, dize G / Ç, 48 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

s.sort(None,a[::-1],1)için steno s.sort(cmp=None,key=a[::-1],reverse=1).

Gönderen docs :

reverse , bir boole değeridir. Eğer ayarlanırsa True, liste elemanları her karşılaştırma ters çevrilmiş gibi sıralanır.

J , 5 bayt

]/:i.

Dyadic fiil, solda alfabeyi ve sağda sıralanacak dizeyi alarak.

i. dizginin karakterlerinin harflerini alfabede, bulunmazsa alfabenin uzunluğunu bulur.

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

/: Sol agrumentini, sağdaki belirtilen sıraya göre sıralar.

] ritim argümanı (dize)

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

Çevrimiçi deneyin!

Piton 2 , 35 50 bayt

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

Çevrimiçi deneyin!

Alır aves ; singelton dizelerinin bir listesini döndürür.

Not: Ah! Düzeltmek için 15 bayt kazanıldı ...

K (ngn / k) , 9 bayt

{y@>-x?y}

Çevrimiçi deneyin!

{... }argümanları olan bir fonksiyondur xvey

x?y içindeki her öğe için bulur y için ilk oluşumunun dizinindex ; eğer bir eleman bulunmazsa x, dizini göz önünde bulundurulur 0N(-2 ⁶³ )

-0N2 - ^{63 'i} sağlam tutması dışında tüm endeksleri olumsuzlar çünkü 2 ⁶³ ≡-2 ⁶³ (mod 2 ⁶⁴ )

> sıralamadan azalan bir permütasyon döndürür

y@ybununla indeksler

Kömür , 13 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

 θ              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

Jöle , 4 bayt

fⱮ;ḟ

Soldaki dize ve sağdaki alfabeyi (karakter listeleri olarak) kabul eden ve sonucu (aynı zamanda bir karakter listesi olarak) döndüren ikili bir bağlantı.

Çevrimiçi deneyin!

Nasıl?

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

APL (Dyalog Unicode) , 5 bayt ^SBCS

Anonim tacit önek işlevi, [string,ordering]argüman olarak alarak .

⍋⍨/⌷⊃

Çevrimiçi deneyin!

… / Aşağıdaki işlevle azaltın:

  … ⍨ Yani şu fonksiyonun ters-argüman versiyonu:

  ⍋ sağdaki dizgiyi soldaki sıralamaya göre derecelendir (eksik harfler sonunda gider)

⌷ bunu indekslemek için kullanın ...

⊃ Argümanın ilk elemanı (dize)

JavaScript (SpiderMonkey), 50 bayt

Kuran sözdiziminde girdi alır (a)(s), burada a bir dizedir ve s bir karakter dizisidir. Bir karakter dizisi döndürür.

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

Çevrimiçi deneyin!

Nasıl?

G () yardımcı fonksiyonunu şu şekilde tanımlarız :

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

hangi döner:

• C alfabeye ait değilse 1
• aksi takdirde (-Inf, -1, -1/2, -1/3, vb.) alfabedeki c pozisyonuna bağlı olarak [-Inf, 0) ' daki bir kayan değer.

Bu sıralama , s [] hesaplayarak g (c) - g (b) karakter her çifti için (b, c) bir geri arama geçirilen tür () .

SpiderMonkey'deki sort () uygulamasının sabit olması nedeniyle, alfabeye ait olmayan tüm s [] karakterleri görünüm sırasına göre basitçe taşınır ve birbirleriyle karşılaştırıldıklarında değişmelerine izin verilmez.

JavaScript (ES6), 61 bayt

Tımar sözdiziminde girişi alır (a)(s)hem bir ve s karakterlerin dizilerdir. Bir dize döndürür.

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

Çevrimiçi deneyin!

R , 69 62 58 bayt

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

Çevrimiçi deneyin!

Giriş ve çıkış, bireysel karakterlerin vektörleridir.

Açıklama:

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

Brain-Flak (BrainHack) , 118 bayt

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

Çevrimiçi deneyin!

Giriş ilk dizedir, ardından null, ardından ikinci dizedir. Ayırıcı olarak newline kullanan bir sürüm, bunun yerine 24 bayt ekler:

Brain-Flak , 142 bayt

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

Çevrimiçi deneyin!

açıklama

# 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
  {({}()<(({}))>)}{}{}

<>{}}<>

C (gcc) , 97 bayt

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];
  }
}

Yukarıdaki koddaki tüm boşluklar _{(boşluklar ve yeni satırlar)} yalnızca okunabilirlik içindir ve kaldırılmalıdır.

Sözlük geçti Dve uzunluğu dgeçti, dize geçti Sve uzunluğu vardı s. ive oihmal edilmeli.

Çevrimiçi deneyin!

Pyth ,  9  5 bayt

ox+vz

Burada dene!

ox + vz Tam program. Giriş biçimi: "S" \ n "A".
o S karakterlerini sırala (değişken: N) ...
 x ... N'nin dizini ...
  + vz ... A + N

Java 8, 98 bayt

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

Çevrimiçi deneyin.

Açıklama:

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`

Perl 5 ile -pF43 byte,

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

Çevrimiçi deneyin!

Prolog (SWI) , 136 bayt

X/_/[X|_].
X/Y/[Z|R]:-Y\=Z,X/Y/R.
i(_,X,[],[X]).
i(A,X,[Y|R],[X,Y|R]):-X/Y/A.
i(A,X,[Y|R],[Y|S]):-i(A,X,R,S).
A*S*T:-foldl(i(A),S,[],T).

Çevrimiçi deneyin! Örnek kullanım:

[i,l]*[n,m,i,u,p,l,l,i,u]*S.
S = [i, i, l, l, n, m, u, p, u]

Temiz , 61 bayt

import StdEnv
$a s=[c\\c<-a,k<-s|k==c]++[c\\c<-s|all((<>)c)a]

Çevrimiçi deneyin!

Fonksiyonu tanımlar $ :: [Char] [Char] -> [Char] .

Şaşırtıcı olmayan bir şekilde, bu kelimenin tam anlamıyla nimi'nin Haskell cevabı ama daha uzun.

Jöle , 7 bayt

i@oİ$¥Þ

Çevrimiçi deneyin!

APL + WIN, 12 bayt

S ardından A ekran girişi istemi:

s[(,⎕)⍋s←,⎕]

Çevrimiçi deneyin! Dyalog Classic'in İzniyle

PynTree , 13 bayt

§yz:ṡzCæf+yxx

Çevrimiçi deneyin!

Jo Kralı Python Limanı'nın cevabı.

açıklama

§yz:ṡzCæf+yxx  Anonymous lambda
§              lambda  ,
 y                    y
  z                     z
   :                     :
    ṡ                     sorted( ,lambda x:
     z                           z
      C                                     (          )( )
       æf                                    (   ).find
         +                                     +
          y                                   y
           x                                    x
            x                                            x