输入：

• 包含三个整数的数组：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

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编码。在线尝试！。

Python 2，67 66字节

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

在Ideone上进行测试。

JavaScript（ES6），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``

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

Pyth，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！

Javascript 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"

TSQL，199个 191字节

打高尔夫球：

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 @

取消高尔夫：

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 @

小提琴

APLX，19 个字节

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

⎕a⎕A⎕D 低位高位数字

(… )[a]根据数组a重新排序

∊ 展平

(… )⍋s根据那个“字母”，给出将对字符串s进行排序的索引

s[...... ]用它来重新排序小号

Python 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],[]))

Clojure，74个字节

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

对于第一个列表中的每个值，获取适当的正则表达式并将其应用于输入字符串。结果是与正则表达式匹配的符号列表的列表。然后对每一个排序，并将结果连接到一个列表中，然后将其转换为字符串。

您可以在此处在线查看：https：//ideone.com/dqAkxg

视网膜，43 39字节

字节数假定为ISO 8859-1编码。尾随换行很重要。

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

输入应作为排序顺序，作为从零开始的，从零开始的列表，而在第一行中没有定界符，在第二行中要对字符串进行排序，例如

120
fOo42BaR

在线尝试！

说明

我将使用上面的输入示例来指导您完成代码：

120
fOo42BaR

阶段1：替代

2=`.
!$&"

正则表达式本身就是正义.（匹配任何非换行符），并用包围!..."。但是，这2=是一个限制，告诉Retina仅将替换应用于正则表达式的第二个匹配项。所以我们得到这个：

1!2"0
fOo42BaR

阶段2：音译

T04`¶d`#^@%

音译阶段仅执行逐个字符的替换。该¶代表换行，并d扩张至0123456789（虽然我们可以忽略毕竟位数2）。也就是说，该音译对应以下映射：

¶012
#^@%

在04在前面的是两个极限，它们一起表明，只有从该集合中的前四个字符应当音译。碰巧是第一行的数字，以及分隔两行的换行符，所以我们得到了：

@!%"^#fOo42BaR

在字符串的开头，我们现在有三对这些字符：

@!
%"
^#

请注意，这对中的第二个字符只是按其正常ASCII顺序排列（并且将始终相同）。稍后我们将使用它们将主输入中的字符组按所需顺序排序。

第一个字符更有趣：它们的含义是%在ASCII表中的数字@之前，大写字母之前（但在数字之后），^小写字母之前（但在大写字母之后）。这将有助于我们将位置标记（即每对中的第二个字符）与正确的字符集进行分组。

第三阶段：排序

O`\W?.

这是一个简单的排序阶段。如果第一个不是单词字符（从而匹配我刚才谈论的所有三对字符），则匹配两个字符；否则匹配单个字符（分别匹配主输入的每个字符），并对这些字符串进行排序。这有两个目的：它带来的字符内以正确的顺序各组（和自排序是稳定的，该顺序将不会在下一阶段弄乱），并且由于%@^标记物，它插入在所述对正确的位置：

%"24@!BOR^#afo

阶段4：排序

O`.\w+

此阶段对.\w+正则表达式的所有匹配项进行排序，由于贪婪，该匹配项将一个位置标记（即的其中之一!"#）与其后的所有单词字符进行匹配。也就是说，它将对这三个字符串进行排序，其顺序完全由标记字符决定：

“ 24！BOR #afo

尽管这会在这些标记周围打乱（同时将其他三个标记保留在原处），但最重要的是，它以正确的顺序显示了数字和字母：

%!BOR@"24^#afo

阶段5：替代

\W

剩下的就是一些清理工作，在这里我们通过匹配所有标记并将其替换为空来删除所有标记。

JavaScript（ES6），65

注意：“自然” ASCII顺序为0-9，AZ，az，与OP 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+')'))
})

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

编辑：@Christian Sievers发现了一个错误。谢谢！固定为另外1个字节。

Stax，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，其读取输入堆栈，而不是两次读取它们全部在开始时主堆叠，并使用不同的（更传统的）输入格式，如图此。

Dyalog APL，22 字节

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

(819⌶⎕A) 将大写字母折叠为小写

(… )⎕A⎕D[a]低位高位数字根据数组a重新排序

∊ 展平

s⍋⍨对于字符串s，获取将根据该“字母” 对s排序的索引

s[...... ]用它来重新排序小号

PowerShell v2 +，107个字节

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

我正在使用正则表达式探索算法，但到目前为止，它们似乎都更长。

将输入作为显式数组$n（请参见下面的示例）和$s立即转换为char数组的字符串。然后，我们正在构建一个新的动态数组的三个元素，他们每个人的封装有-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

Ruby，56个字节

从@Dennis答案移植。

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

我更喜欢的另一种58字节解决方案，受@Neil启发，并从他的回答中稍作修改。

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

在线尝试任何一个版本！（注释掉的版本是替代解决方案）

32位x86机器代码，70字节

十六进制：

fc31c031c95189e3ac84c0740a34cf0404880c0341ebf189fe9160ac88c2c0e805d788c652ac88c2c0e805d788c658740e6639d076029241aa92aa4e4febdc85c96175d658c3

此过程期望字符类的排序顺序为3字符（0..2）以NULL终止的字符串，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

Emacs Lisp，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))))))))

比Java短一点...

Clojure，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如果要处理更多的字符类，这将比解决方案更紧凑，因为这仅需要5个额外的字符/组（例如），57 1,而不是8个字符/组（例如）#"[a-z]"。

Python 2中，140个 117 101 100 99字节

每个人都说“ Ewww！”。至少它是可读的... 咳嗽不是真的咳嗽

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]

在线尝试

R，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的向量，并对输入字符串的字符重新排序以匹配此顺序。

在线尝试！

J，40个字节

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

爪哇8，221个 212 193 156字节

我当然也应该尝试回答自己的挑战。:)（和Java中一样。）

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());}

@cliffroot节省了-28字节。

说明：

在这里尝试。

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