您面临的挑战是对字符串进行排序，而不是按照正常的字母顺序（abc..xyz），而是按指定的字母对字符串进行排序。

你必须写一个程序或功能有两个输入端：一个字母一个和串小号。两者都将仅包含小写英文字母，并且都将包含至少一个字符。

您必须在移动字母小号，使得第一次出现在信一出现，再取其信在第二出现一个，等有可能会在某些字母小号没有出现在一，这些都应该在年底左右不能相对移动。

测试用例：

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

最小字节获胜！

05AB1E，4个字节

Rvy†

在线尝试！

说明

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

Python 3中，50 47 46 44个字节

-3个字节，感谢ngn！

-1字节归功于mypetlion

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

在线尝试！

接受一个字符串作为字母，并输入一个字符列表作为字符串，并对列表进行适当排序。

在%27确保如果字符不是字母，指数字母后剩下的返回所说的那样。

Haskell，42个字节

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

在线尝试！

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个字节

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

Haskell，40 34字节

多亏莱科尼了-6个字节。

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

在线尝试！

第一行是有两个参数的表达式：小号和甲。

Stax，6个字节

{xrINo

运行并调试

这按执行此操作的块排序。

• 反转字母。
• 获取反向字母中每个字符的索引。缺少收益-1。
• 否定索引。

Python 2，38个字节

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

a必须是一个字符串，s是一个长度为1的字符串的列表。f对s进行适当排序。

在线尝试！

备用版本，字符串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)。

从文档：

reverse是一个布尔值。如果设置为True，则对列表元素进行排序，就好像每个比较都被反转一样。

J，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

在线尝试！

Python 2中，35 50个字节

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

在线尝试！

以a和s作为字符串；返回singelton字符串列表。

注意：哎呀！获得15个字节来修复...

K（ngn / k），9个字节

{y@>-x?y}

在线尝试！

{... }是参数的函数x和y

x?y在y中首次出现的索引中查找每个元素x; 如果在中找不到元素，则将x其索引视为0N（-2 ⁶³）

-则无效不同之处在于它使所有索引0N-s完好，因为2 ⁶³ ≡-2 ⁶³（模2 ⁶⁴）

> 返回降序排列

y@y用那个索引

木炭，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

果冻，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

APL（Dyalog Unicode），5 字节^SBCS

匿名默认前缀函数，以实参为准[string,ordering]。

⍋⍨/⌷⊃

在线尝试！

… / 通过以下功能减少：

  … ⍨ 即以下功能的反向参数版本：

  ⍋ 根据左顺序对右字符串分级（末尾缺少字母）

⌷ 用它来索引...

⊃ 参数的第一个元素（即字符串）

JavaScript（SpiderMonkey），50个字节

以currying语法接受输入(a)(s)，其中a是字符串，而s是字符数组。返回一个字符数组。

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

在线尝试！

怎么样？

我们将辅助函数g（）定义为：

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

返回：

• 如果c不属于字母，则为1
• 基于字母c的位置的[-Inf，0）中的浮点值，否则（-Inf，-1，-1 / 2，-1 / 3等）

我们通过为传递给sort（）回调的每对字符（b，c）计算g（b）-g（c）来对s []进行排序。

因为SpiderMonkey 中sort（）的实现是稳定的，所以不属于字母的s []的所有字符都按照出现的顺序简单地在末尾移动，并且当它们相互比较时，它们保持不变。

JavaScript（ES6），61个字节

以currying语法接受输入(a)(s)，其中a和s均为字符数组。返回一个字符串。

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

在线尝试！

R，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

Brain-Flak（BrainHack），118字节

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

在线尝试！

输入是第一个字符串，后跟一个空值，然后是第二个字符串。使用换行符作为分隔符的版本会增加24个字节：

Brain-Flak，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
  {({}()<(({}))>)}{}{}

<>{}}<>

C（gcc），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应省略。

在线尝试！

Pyth， 9  5字节

ox+vz

在这里尝试！

ox + vz完整程序。输入格式：“ S” \ n“ A”。
o将S的字符排序为（变量：N）...
 x ... N的索引在...
  + vz ... A + N

Java 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`

Perl 5的与-pF，43个字节

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

在线尝试！

Prolog（SWI），136字节

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

在线尝试！用法示例：

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

干净，61字节

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

在线尝试！

定义函数$ :: [Char] [Char] -> [Char]。

毫不奇怪，这实际上是nimi的Haskell答案，但更长。

果冻，7个字节

i@oİ$¥Þ

在线尝试！

APL + WIN，12个字节

提示输入S到A：

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

在线尝试！由Dyalog Classic提供

PynTree，13个字节

§yz:ṡzCæf+yxx

在线尝试！

Jo King的Python答案端口。

说明

§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