Thử thách của bạn là sắp xếp một chuỗi, nhưng thay vì theo thứ tự bảng chữ cái thông thường (abc..xyz), bạn sẽ sắp xếp các chuỗi theo một bảng chữ cái được chỉ định.

Bạn phải viết một chương trình hoặc chức năng mà có hai đầu vào: Một bảng chữ cái A và một chuỗi S . Cả hai sẽ chỉ chứa các chữ cái tiếng Anh viết thường và cả hai sẽ chứa ít nhất một ký tự.

Bạn phải di chuyển các chữ cái trong S để chữ cái xuất hiện đầu tiên trong A xuất hiện đầu tiên, sau đó bất kỳ chữ cái nào xuất hiện thứ hai trong A , v.v. Có thể có một số chữ cái trong S không xuất hiện ở A , những chữ cái này nên được để lại ở cuối và không di chuyển xung quanh tương đối với nhau.

Các trường hợp thử nghiệm:

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

Ít byte nhất sẽ thắng!

05AB1E , 4 byte

Rvy†

Hãy thử trực tuyến!

Giải trình

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

Python 3 , 50 47 46 44 byte

-3 byte nhờ ngn!

-1 byte nhờ vào mypetlion

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

Hãy thử trực tuyến!

Lấy một chuỗi là bảng chữ cái và một danh sách các ký tự như chuỗi và sắp xếp danh sách tại chỗ.

Việc %27đảm bảo rằng nếu ký tự không nằm trong bảng chữ cái, chỉ mục được trả về sẽ đặt nó sau phần còn lại của bảng chữ cái.

Haskell, 42 byte

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

Hãy thử trực tuyến!

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 byte

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

Thử nó

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

Thử nó

Mở rộng:

-> \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 byte

-6 byte rất lớn nhờ Laikoni .

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

Hãy thử trực tuyến!

Dòng đầu tiên là một biểu hiện rằng hai đối số: S và A .

Stax , 6 byte

{xrINo

Chạy và gỡ lỗi nó

Điều này sắp xếp bởi một khối mà làm điều này.

• Đảo ngược bảng chữ cái.
• Lấy chỉ số của từng ký tự trong bảng chữ cái đảo ngược. Thiếu năng suất -1.
• Phủ định chỉ số.

Python 2 , 38 byte

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

a phải là một chuỗi, s một danh sách các chuỗi có độ dài 1. f sắp xếp s đúng vị trí.

Hãy thử trực tuyến!

Phiên bản thay thế, chuỗi I / O, 48 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

s.sort(None,a[::-1],1)là tốc ký cho s.sort(cmp=None,key=a[::-1],reverse=1).

Từ các tài liệu :

đảo ngược là một giá trị boolean. Nếu được đặt thành True, thì các thành phần danh sách được sắp xếp như thể mỗi so sánh được đảo ngược.

J , 5 byte

]/:i.

Động từ Dyadic, lấy bảng chữ cái bên trái và chuỗi được sắp xếp ở bên phải.

i. tìm thấy các ký tự của chuỗi ký tự trong bảng chữ cái, chiều dài bảng chữ cái nếu không tìm thấy.

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

/: sắp xếp bên trái của nó theo thứ tự được chỉ định trong bên phải.

] đối số cứng (chuỗi)

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

Hãy thử trực tuyến!

Python 2 , 35 50 byte

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

Hãy thử trực tuyến!

Mất avà snhư chuỗi; trả về một danh sách các chuỗi singelton.

Lưu ý: Ouch! Đạt được 15 byte để sửa ...

K (ngn / k) , 9 byte

{y@>-x?y}

Hãy thử trực tuyến!

{... }là một hàm với các đối số xvày

x?ytìm thấy cho mỗi phần tử trong ychỉ mục của lần xuất hiện đầu tiên của nó trong x; nếu không tìm thấy một phần tử x, chỉ mục của nó được xem xét 0N(-2 ⁶³ )

-phủ nhận tất cả các chỉ số ngoại trừ việc nó giữ nguyên các 0N-s, bởi vì 2 ⁶³ 2-2 ⁶³ (mod 2 ⁶⁴ )

> trả về một hoán vị giảm dần sắp xếp

y@lập chỉ mục yvới điều đó

Than , 13 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

 θ              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

Thạch , 4 byte

fⱮ;ḟ

Một liên kết dyadic chấp nhận chuỗi ở bên trái và bảng chữ cái ở bên phải (dưới dạng danh sách các ký tự) và trả về kết quả (cũng như một danh sách các ký tự).

Hãy thử trực tuyến!

Làm sao?

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 byte ^SBCS

Hàm tiền tố ẩn danh, lấy [string,ordering]làm đối số.

⍋⍨/⌷⊃

Hãy thử trực tuyến!

... / Giảm chức năng sau:

  ... ⍨ cụ thể là đảo ngược-đối số phiên bản của chức năng sau:

  ⍋ chấm điểm chuỗi bên phải theo thứ tự bên trái (thiếu chữ đi ở cuối)

⌷ dùng cái đó để lập chỉ mục

⊃ phần tử đầu tiên của đối số (tức là chuỗi)

JavaScript (SpiderMonkey), 50 byte

Đưa đầu vào theo cú pháp currying (a)(s), trong đó a là một chuỗi và s là một mảng các ký tự. Trả về một mảng các ký tự.

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

Hãy thử trực tuyến!

Làm sao?

Chúng tôi định nghĩa hàm trợ giúp g () là:

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

Trả về:

• 1 nếu c không thuộc bảng chữ cái
• một giá trị float trong [-Inf, 0) dựa trên vị trí của c trong bảng chữ cái nếu không (-Inf, -1, -1/2, -1/3, v.v.)

Chúng tôi sắp xếp s [] bằng cách tính g (b) - g (c) cho mỗi cặp ký tự (b, c) được chuyển đến hàm gọi lại của sort () .

Vì việc triển khai sort () trong SpiderMonkey là ổn định, tất cả các ký tự của s [] không thuộc bảng chữ cái chỉ được di chuyển ở cuối theo thứ tự xuất hiện và không thay đổi khi chúng được so sánh với nhau.

JavaScript (ES6), 61 byte

Đưa đầu vào theo cú pháp currying (a)(s), trong đó cả a và s là mảng các ký tự. Trả về một chuỗi.

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

Hãy thử trực tuyến!

R , 69 62 58 byte

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

Hãy thử trực tuyến!

Đầu vào và đầu ra là các vectơ của các ký tự riêng lẻ.

Giải trình:

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 byte

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

Hãy thử trực tuyến!

Đầu vào là chuỗi đầu tiên, theo sau là null, tiếp theo là chuỗi thứ hai. Một phiên bản sử dụng một dòng mới làm dấu phân cách thay vào đó thêm 24 byte:

Brain-Flak , 142 byte

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

Hãy thử trực tuyến!

Giải trình

# 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 byte

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

Tất cả các khoảng trắng _{(dấu cách và dòng mới)} trong đoạn mã trên chỉ dành cho khả năng đọc và cần được loại bỏ.

Từ điển được truyền vào Dvà có độ dài d, chuỗi được truyền vào Svà có độ dài s. ivà onên được bỏ qua.

Hãy thử trực tuyến!

Bình thường ,  9  5 byte

ox+vz

Hãy thử nó ở đây!

ox + vz Chương trình đầy đủ. Định dạng đầu vào: "S" \ n "A".
o Sắp xếp các ký tự của S theo (biến: N) ...
 x ... Chỉ số của N trong ...
  + vz ... A + N

Java 8, 98 byte

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

Hãy thử trực tuyến.

Giải trình:

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 với -pF, 43 byte

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

Hãy thử trực tuyến!

Prolog (SWI) , 136 byte

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).

Hãy thử trực tuyến! Ví dụ sử dụng:

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

Sạch , 61 byte

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

Hãy thử trực tuyến!

Xác định hàm $ :: [Char] [Char] -> [Char].

Không có gì đáng ngạc nhiên, đây đúng là câu trả lời Haskell của nimi nhưng dài hơn.

Thạch , 7 byte

i@oİ$¥Þ

Hãy thử trực tuyến!

APL + THẮNG, 12 byte

Lời nhắc cho màn hình nhập của S rồi A:

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

Hãy thử trực tuyến! Lịch sự của Dyalog Classic

PynTree , 13 byte

§yz:ṡzCæf+yxx

Hãy thử trực tuyến!

Cảng của câu trả lời Python của Python.

Giải trình

§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